r/pythontips

I just shipped ArchUnitPython, a library that lets you enforce architectural rules in Python projects through automated tests.

The problem it solves: as codebases grow, architecture erodes. Someone imports the database layer from the presentation layer, circular dependencies creep in, naming conventions drift. Code review catches some of it, but not all, and definitely not consistently.

This problem has always existed but is more important than ever in Claude Code, Codex times. LLMs break architectural rules all the time.

So I built a library where you define your architecture rules as tests. Two quick examples:

# No circular dependencies in services
rule = project_files("src/").in_folder("**/services/**").should().have_no_cycles()
assert_passes(rule)

# Presentation layer must not depend on database layer
rule = project_files("src/")
          .in_folder("**/presentation/**")
          .should_not()
          .depend_on_files()
          .in_folder("**/database/**")
assert_passes(rule)

This will run in pytest, unittest, or whatever you use, and therefore be automatically in your CI/CD. If a commit violates the architecture rules your team has decided, the CI will fail.

Hint: this is exactly what the famous ArchUnit Java library does, just for Python - I took inspiration for the name is of course.

Let me quickly address why this over linters or generic code analysis?

Linters catch style issues. This catches structural violations — wrong dependency directions, layering breaches, naming convention drift. It's the difference between "this line looks wrong" and "this module shouldn't talk to that module."

Some key features:

• Dependency direction enforcement & circular dependency detection
• Naming convention checks (glob + regex)
• Code metrics: LCOM cohesion, abstractness, instability, distance from main sequence
• PlantUML diagram validation — ensure code matches your architecture diagrams
• Custom rules & metrics
• Zero runtime dependencies, uses only Python's ast module
• Python 3.10+

Very curious what you think! https://github.com/LukasNiessen/ArchUnitPython

https://github.com/simplyyrayyan/Rock-Paper-Scissors-Game/blob/main/RockPaperScissors.py This is the Source Code My first Python Project ever i pieced together with google and teh little bit of python I already knew so yeah any tips or things I didn't Catch?

For anyone studying Dog Segmentation Magic: YOLOv8 for Images and Videos (with Code):

The primary technical challenge addressed in this tutorial is the transition from standard object detection—which merely identifies a bounding box—to instance segmentation, which requires pixel-level accuracy. YOLOv8 was selected for this implementation because it maintains high inference speeds while providing a sophisticated architecture for mask prediction. By utilizing a model pre-trained on the COCO dataset, we can leverage transfer learning to achieve precise boundaries for canine subjects without the computational overhead typically associated with heavy transformer-based segmentation models.

 

The workflow begins with environment configuration using Python and OpenCV, followed by the initialization of the YOLOv8 segmentation variant. The logic focuses on processing both static image data and sequential video frames, where the model performs simultaneous detection and mask generation. This approach ensures that the spatial relationship of the subject is preserved across various scales and orientations, demonstrating how real-time segmentation can be integrated into broader computer vision pipelines.

Deep-dive video walkthrough: https://youtu.be/eaHpGjFSFYE

 

This content is provided for educational purposes only. The community is invited to provide constructive feedback or post technical questions regarding the implementation details.

 

Eran Feit

For anyone studying computer vision and semantic segmentation for environmental monitoring.

The primary technical challenge in implementing automated flood detection is often the disparity between available dataset formats and the specific requirements of modern architectures. While many public datasets provide ground truth as binary masks, models like YOLOv8 require precise polygonal coordinates for instance segmentation. This tutorial focuses on bridging that gap by using OpenCV to programmatically extract contours and normalize them into the YOLO format. The choice of the YOLOv8-Large segmentation model provides the necessary capacity to handle the complex, irregular boundaries characteristic of floodwaters in diverse terrains, ensuring a high level of spatial accuracy during the inference phase.

The workflow follows a structured pipeline designed for scalability. It begins with a preprocessing script that converts pixel-level binary masks into normalized polygon strings, effectively transforming static images into a training-ready dataset. Following a standard 80/20 data split, the model is trained with specific attention to the configuration of a single-class detection system. The final stage of the tutorial addresses post-processing, demonstrating how to extract individual predicted masks from the model output and aggregate them into a comprehensive final mask for visualization. This logic ensures that even if multiple water bodies are detected as separate instances, they are consolidated into a single representation of the flood zone.

 

Deep-dive video walkthrough: https://youtu.be/diZj_nPVLkE

 

This content is provided for educational purposes only. Members of the community are invited to provide constructive feedback or ask specific technical questions regarding the implementation of the preprocessing script or the training parameters used in this tutorial.

 

#ImageSegmentation #YoloV8

Hey everyone,

One of the most common (and annoying) security issues in backend development is accidentally logging PII like emails, credit card numbers, or phone numbers. I got tired of writing custom regex filters for every new project's logger, so I built an open-source package to solve it automatically.

It’s called hushlog.

What it does: It provides zero-config PII redaction for Python logging. With just one call to hushlog.patch(), it automatically scrubs sensitive data before it ever hits your console or log files.

Links:

• GitHub:https://github.com/FelipeMorandini/hushlog
• PyPI:https://pypi.org/project/hushlog/
• Docs:https://felipemorandini.github.io/hushlog/

I’d love for you to try it out, tear it apart, and let me know what you think! Any feedback on the codebase, edge cases I might have missed, or feature requests would be incredibly appreciated.

What My Project Does: Claude Code plugin that reviews Python/FastAPI code against Clean Architecture principles. Reports issues by severity with file/line references and fix snippets.

Target Audience: Python developers using FastAPI who want automated architecture feedback beyond what linters catch.

Comparison: Linters like ruff and flake8 catch style and syntax. This catches structural problems: business logic in routers, layer skipping, tight coupling, god classes, ABC where Protocol would do.

I built a Claude Code plugin that does architecture reviews on Python/FastAPI code. You run `/review-architecture [path]` and it checks your code against 7 design principles, 17 quality rules, and three-layer architecture compliance, then reports findings by severity with file/line references and fix snippets.

Repo: https://github.com/MKToronto/python-clean-architecture

It catches things linters don't, business logic leaking into routers, layer skipping, ABC where Protocol would do, if/elif chains that should be dict mappings, tight coupling, god classes. Inspired by Arjan Codes, very opinionated toward Pythonic patterns.

Would you use this? What should an architecture reviewer catch that this doesn't?

For anyone studying  YOLOv8 Auto-Label Segmentation ,

The core technical challenge addressed in this tutorial is the significant time and resource bottleneck caused by manual data annotation in computer vision projects. Traditional labeling for segmentation tasks requires meticulous pixel-level mask creation, which is often unsustainable for large datasets. This approach utilizes the YOLOv8-seg model architecture—specifically the lightweight nano version (yolov8n-seg)—because it provides an optimal balance between inference speed and mask precision. By leveraging a pre-trained model to bootstrap the labeling process, developers can automatically generate high-quality segmentation masks and organized datasets, effectively transforming raw video footage into structured training data with minimal manual intervention.

 

The workflow begins with establishing a robust environment using Python, OpenCV, and the Ultralytics framework. The logic follows a systematic pipeline: initializing the pre-trained segmentation model, capturing video streams frame-by-frame, and performing real-time inference to detect object boundaries and bitmask polygons. Within the processing loop, an annotator draws the segmented regions and labels onto the frames, which are then programmatically sorted into class-specific directories. This automated organization ensures that every detected instance is saved as a labeled frame, facilitating rapid dataset expansion for future model fine-tuning.

 

Deep-dive video walkthrough: https://youtu.be/tO20weL7gsg

 

This content is for educational purposes only. The community is invited to provide constructive feedback or ask technical questions regarding the implementation or optimization of this workflow.

 

Eran Feit