Consider this in src/app/domain/pricing.py:

from __future__ import annotations
from typing import TYPE_CHECKING

if TYPE_CHECKING:
    from app.adapters.store import Store

def price(store: Store):
    return 12

The adapter isn't imported by that guarded block at runtime. But the domain still names Store, and moving or renaming that type can still require changing the domain code.

So whether this should fail an architecture test depends on the policy you're trying to enforce. If domain code mustn't know about adapters at all, the type-only edge matters. If you're deliberately allowing those annotations while checking the other imports, you need to exclude it explicitly.

In ArchUnitPython, which I work on, imports inside TYPE_CHECKING count by default. The same boundary can be checked with them excluded:

from archunitpython import CheckOptions, assert_passes, project_files

rule = (
    project_files("src")
    .in_path("**/domain/**")
    .should_not()
    .depend_on_files()
    .in_path("**/adapters/**")
)

assert_passes(
    rule,
    CheckOptions(ignore_type_checking_imports=True),
)

That passes for the snippet above. Move the Store import outside the guard and it fails again, even with the option enabled. Without the option, the guarded version fails too.

A small distinction with quite different consequences

I would choose the policy first, rather than switch the option on just to make a failing test green. This is still static import analysis; excluding typing guards doesn't turn it into a trace of everything Python will execute.

ArchUnitPython source. Free, MIT-licensed; the example works with archunitpython==1.8.1.

Replacing a normal import with importlib.import_module() doesn't necessarily make the dependency disappear. Sometimes the target is still sitting there as a string literal.

I maintain ArchUnitPython. It can include a call such as importlib.import_module("app.adapters.store") in a dependency rule, so moving that import into a plugin factory doesn't automatically avoid the boundary check.

I verified a domain-to-adapter rule against both forms. The ordinary import failed, and the literal dynamic import failed too.

There's a limit worth knowing: when the module name comes from an environment variable or another computed value, the analysis cannot infer it from that literal. An omitted edge isn't evidence that no runtime dependency exists.

This is useful for projects with a mix of regular imports and simple plugin loading. You can enforce the relationships that are statically visible while keeping the genuinely dynamic part explicit in your review and tests.

Source: https://github.com/LukasNiessen/ArchUnitPython

I built ArchUnitPython to check dependency rules in Python projects, and recorded the workflow here.

The example has a taskboard package with domain and infrastructure folders. The rule says that files in the domain folder must not depend on files in infrastructure. If somebody introduces that import, the architecture test reports it.

The recording also covers a cycle check and a custom rule limiting file size. Those run through pytest like other tests; the library reads the source instead of starting the application.

One thing to get right is the import root. This example uses project_files("src") because src contains the taskboard package. The path filters then choose which parts of that project the rule applies to.

The recording shows archunitpy imports; the current package uses archunitpython. The README has the current setup and examples.

Repo: https://github.com/LukasNiessen/ArchUnitPython

Built a small open-source project called Litmus.

It’s a CLI for evaluating prompts across different LLMs with:

• dataset-based testing

• assertions

• model comparisons

• metrics like cost, latency, and output quality

Idea is simple: prompt engineering needs a better dev workflow than copy-pasting into multiple tabs.

GitHub: https://github.com/litmus4ai/litmus

Would love honest feedback from Python / CLI folks:

• Is this something you’d use?

• What would make the UX better?

• If you like the direction, I’d really appreciate a star on GitHub.

Hi all,
I've successfully create script to find and download attachments from my Outlook. I work OK running it on my desktop while my Outlook is open.
In the code I don't see any Auth logic, looks like everything was taken care by package, thanks to them, it's so easy..
But now I try to run this .py on remote prod server, is it possible ? I assume need to point to the right Outlook endpoint for given email and go thru complete Authentication. Probably it's not worth it.. Though people on support said I can't leave on my machine in production.

Thanks to all.

Below is pseudo logic I'm using:

import win32com.client
....
for message in messages:
....
  attachments = message.Attachment
  for attachment in attachments:
    attachment.SaveAsFile(os.path,str(attachment)))
...

I’m a college student in the US, and not gonna lie — I used to think Python was just one of those classes you take, pass, and then forget.

But after actually looking into it (and seeing what people around me are doing with it), it’s way more practical than I expected.

Like in AI/ML — all that stuff you hear about, chatbots, recommendations on Netflix/YouTube, even face unlock — a lot of it is built using Python.

Then there’s data stuff. Companies are using it to figure out what users are doing, what’s working, what’s not. Basically turning raw data into decisions.

Web dev too — Python handles backend things like logins, databases, APIs. Stuff you don’t see, but everything depends on.

Honestly though, the most relatable use is automation. People literally write small scripts to do boring tasks for them — organizing files, scraping info, sending emails, etc. Saves a ton of time.

It also shows up in cybersecurity, finance (like trading bots), research, and even basic game dev.

A simple example — if you’re into fitness, you could make a script to track your calories, protein, and progress instead of doing it manually.

Main reasons people stick with it:

- Pretty easy to pick up

- Can be used in a lot of different fields

- Actually useful for jobs/internships

So yeah, definitely not just a “beginner language.”

Kinda curious — what made you look into Python?

I spent way too long writing custom JSON parsers for LLM responses, dealing with surprise API bills, and maintaining separate code for different providers.

Turns out there are libraries that solve these exact problems. Here are three that can save you from repeating the same mistakes:

1. Instructor - Get structured, validated data from LLMs without the parsing nightmare. Define a Pydantic model, get guaranteed JSON. No more handling markdown code fences or trailing commas.

2. tiktoken - Count tokens BEFORE you make API calls. I've seen prompts balloon to 30k+ tokens in production when they should be 3k. This helps you budget and optimize before burning money.

3. LiteLLM - One interface for OpenAI, Anthropic, Google, Llama, and 100+ other providers. Switch models with one line of code instead of rewriting integrations.

None of these are frameworks. They're focused tools that do one thing well and get out of your way.

Wrote a detailed breakdown with code examples here: Medium

Anyone else have libraries that replaced chunks of their AI boilerplate? Would love to hear what's working for you.

Understanding a data structure like linked list in Python is a lot easier when you can just see it. Linked_List demo

memory_graph visualizes Python objects and references, so data structures stop being abstract and become something you can debug with ease. No more endless print-debugging. No more stepping through 50 frames just to find one sneaky reference/aliasing mistake.

An exercise to help build the right mental model for Python data. The “Solution” link uses memory_graph to visualize execution and reveals what’s actually happening:

• Solution

• Explanation

• More exercises

It's instructive to compare with this earlier exercise (tuple with lists, instead of list with lists).

I’ve been trying to learn Python for career growth, but honestly, figuring out where to start has been harder than expected. When I searched for a python training institute near me in Thane, I found a lot of options, but very little clarity on what actually helps beginners.

From my experience, Python itself isn’t the hardest part. The real challenge is understanding logic, practicing regularly, and knowing how Python is used in real projects. Many beginners (including me) jump between YouTube videos and blogs and end up feeling stuck.

What made learning easier was structured guidance—either online or instructor-led—where concepts were explained step by step with examples. A few learners I spoke to mentioned that learning at Quastech IT Training & Placement Institute, Thane helped them understand fundamentals better because topics were connected instead of taught randomly.

I’m still learning and trying to stay consistent, but at least now the path feels clearer.

For others learning Python—what helped you the most in the beginning: self-study, classes, or real projects?