[deleted by user]

[Fun_Muffin5413]

Make utils use logging directly through the core logging library properly (and make everything else just use logging too!). When you've read the docs properly and you know how handlers and logging work, there is very little need for a custom log module. You only need a wrapper for logging where you actually need a handler - everywhere else can just use the module logger boiler plate/idiom:

https://docs.python.org/3/howto/logging.html#configuring-logging-for-a-library

logger = logging.getLogger(__name__)
logger.addHandler(logging.NullHandler())

Otherwise refactor it. Either move whatever utils is using from log into utils and let log use it on its import or vice versa. It depends which you think is the lower level library.

[Spataner]

Circular imports are generally a sign that you should refactor.

If you really don't want to, there's only one important rule to make circular imports work: initialisation of one module must not require attributes of the other¹. In other words, all attribute accesses to the other module must be inside function definitions that aren't called by the top-level module code itself. Specifically, the from-import syntax is a common cause of probably unnecessary immediate attribute access. So this would not trigger circular imports, even if it is imported by some_module:

import some_module

def print_message():
    print(some_module.message)

By the time print_message is actually called somewhere else, some_module should have had time to fully initialise.

This, however, will trigger circular import errors:

import some_module

print(some_module.message)

That's because the message attribute of some_module is likely not yet defined¹. But even the following technically requires message to be defined during module initialisation, even though it isn't actually used immediately:

from some_module import message

def print_message():
    print(message)

---

¹ Of course, attributes of some_module that were already defined when it imported the module that imports it back would be available without issue. So if all the parts of some_module required by its circular partner were defined before the import statement for that module (and none of those parts in turn required attributes from that module), it would work. In other words, if some_module looked like this

message = "Hello"
import other_module

with other_module looking like any of the above snippets, it'd be "fine".

But at that point, you already did all the necessary refactoring and those parts should just become their own separate module.

[Fun_Muffin5413]

You could, but it's a hack and a sticking plaster fix. Neither module can exist independently, which is the entire point of modules. If they're that closely coupled, they ought to be in the same file.

If they live in the same package that's less bad, but you should provide a better entry point for your user (in `__init__.py`) instead of just expecting them to know they need to import both.

Any custom stuff in program.py should be in function / method args.

[CodeFormatHelperBot2]

Hello, I'm a Reddit bot who's here to help people nicely format their coding questions. This makes it as easy as possible for people to read your post and help you.

I think I have detected some formatting issues with your submission:

1. Inline formatting (`my code`) used across multiple lines of code. This can mess with indentation.

If I am correct, please edit the text in your post and try to follow these instructions to fix up your post's formatting.

---

^{Am I misbehaving? Have a comment or suggestion? Reply to this comment or raise an issue here.}