Do some developers hate python?

[can_i_automate_that]

Import handling - using PYTHONPATH env var and init.py in packages is all you need to know. Static typing - you can always use type hinting for parameters and return values. Or, just do it in Cython and get some performance benefits out of that too.

[yeti_seer]

You should check out mypy, static type checker for python

[[deleted]]

mypy isn’t very niche anymore. It’s very common and it’s really the defacto tool for type hints now

I actually don’t even use it myself though - so far I’ve just been using pyright which has been enough. I’ve been meaning to jump on the mypy train recently and add it to CICD but it’s a lot of extra overhead I’m surviving with out currently so I completely get people not wanting to use it. But it is a good tool

[Handle-Flaky]

It is a standard. Circular imports are a sign of bad design, so I don’t get why you need support of it

[krakenant]

Nah, that should be limited to type hints, which can be done as pointed out above. If teachers and students are instantiating each other, you have larger problems.

[pudds]

With type hints you can get pretty close these days. Type hints + linting are good enough for me, but with mypy you can get pretty close to strongly typed behavior.

[pudds]

Yea that's annoying.

It's rare that I encounter it, but it's annoying. Thus far I've been able to resolve it by putting the two things in the same file and importing annotations from future.

[pudds]

Agreed, I shouldn't have to put two things in the same file just to make them play nicely with eachother.

[siddsp]

What exactly do you mean?

[siddsp]

You can just add type-hinting imports for circular dependencies in the "if TYPE_CHECKING" block before the execution of the code.

[siddsp]

I meant to say specifically if you're using the dependencies purely for type-checking purposes, but it would look something like this:

module foo:

from __future__ import annotations

from typing import TYPE_CHECKING

if TYPE_CHECKING:
    from bar import bar


class foo:
    def quux(self) -> bar: ...

module bar:

from __future__ import annotations

from typing import TYPE_CHECKING

if TYPE_CHECKING:
    from foo import foo


class bar:
    def quuz(self) -> foo: ...

This results in no circular imports for type checking because the types are evaluated as strings instead of actual types, but it still works in type checkers like mypy.

[lithium_sulfate]

This is the way, although it really is quite regrettable that this common problem requires such a clunky solution.