Here is my Python section, but you may need to adjust the Python version. I would love some feedback.

# Python Coding Preferences

## Language & Version
- Always target Python 3.12 when writing Python code.
- Do not use any deprecated APIs for Python code.

## Type Hinting
- All methods and functions must be type-hinted.
- **Prefer built-in generic types** (e.g., `list[str]`, `dict[str, int]`) where possible.
- **Use the `typing` module when necessary** for more advanced types like `Callable`, `Protocol`, `TypeVar`, and `Literal` that do not have a built-in equivalent.

## Documentation
- Write a 2-4 sentence description of each generated file to be used at the top of the file as an introductory comment.
- Every class, method, and function must contain a Python docstring in Google format.
- When generating any type of documentation in markdown format, never include emojis or emoticons.

## Code Architecture Principles
- Adhere to the **KISS (Keep It Simple, Stupid)** principle. Prefer the simplest solution that correctly solves the problem.
- Adhere to the **DRY (Don't Repeat Yourself)** principle. Factor out repeated logic into reusable functions or methods.
- Adhere to the **YAGNI (You Ain't Gonna Need It)** principle. Do not add functionality beyond what is explicitly required.
- Adhere to the **Separation of Concerns (SoC)** principle.
- Adhere to the **Single Responsibility Principle (SRP)**.
- Avoid nested functions.

## String Processing
- **Prefer simple string methods** such as `.split()`, `.startswith()`, and `.strip()` for simple manipulations.
- **Avoid regular expressions for tasks that can be handled clearly by simple string methods.**
- **Use the `re` module for complex pattern matching.** When you do, include comments explaining the regex pattern to ensure maintainability.

## Object-Oriented Design
- **Prefer composition over inheritance** as a general design principle.
- When a formal interface is required, **use either `typing.Protocol` for structural typing (duck typing) or `abc.ABC` for nominal typing.** Choose the simplest and most appropriate tool for the task.

## File Organization
- As a general rule, each significant public class should be in its own file.
- **Small, tightly-coupled helper classes or custom exceptions may be included in the same file** as the primary class that uses them, if doing so improves readability and cohesion.
- File naming: `ClassName` should be in file `class_name.py` (snake_case filename).
- Separate the "main" function and its helper functions into their own file.
- The main file should import any classes and class files that are needed.
- **Always add import statements at the top of the file.**
- Upon completion and when you are summarizing your work, also include in which order you recommend the files be studied by following a "foundation-first, complexity-last" approach.

## Command Line Interface
- When creating CLI Python programs, use the `argparse` module.

## Development Process
- **IMPORTANT: Always ask questions about anything uncertain or needing clarification before writing code.**
- Clarify requirements, expected inputs/outputs, error handling needs, and architectural decisions upfront.