Abstract:

César Soto Valero details his transition to Python for building "production-ready" AI applications, driven by Python's dominance in the AI field and its significant improvements in ecosystem, performance, and syntax over the past decade. He addresses the gap between casual scripting and robust application development by sharing his comprehensive toolkit and methodology. This includes a preference for monorepo project structures, and a curated set of tools for package management (uv), code quality (ruff, ty), testing (pytest), data validation (Pydantic), documentation (MkDocs), API development (FastAPI), and boilerplate reduction (Dataclasses). He also outlines his version control practices leveraging GitHub Actions, Dependabot, Gitleaks, and pre-commit hooks, alongside infrastructure management with Make and Docker/Docker Compose for consistent and deployable applications.

Summarizing "I'm Switching to Python and Actually Liking It"

• Motivation for Python Shift: The author transitioned to serious Python development six months prior, primarily driven by the "big money opportunities" in AI, for which Python is the "de facto programming language." Previously, Python was used only for small scripts.
• Python's Recent Improvements: The author notes significant advancements in Python, including a complete ecosystem for data processing/analysis, performance gains via static compilers like Cython, and improved syntax that hides legacy complexities, leading to a "particular joy for the language."
• The Production Gap: A key challenge identified is the significant difference between using Python for scripts/Jupyter notebooks and building "production-ready" applications. This post aims to share tools and practices to bridge that gap.
• Project Structure (Monorepo Preference):
  • Why Monorepo: Preferred due to the author's "bad memory" (avoids scattered code), belief that multiple repos are often unnecessary for single developers, and laziness (simplifies compilation, testing, containerization, deployment).
  • Typical Structure: Outlines a detailed monorepo structure including .github (CI/CD), .vscode (IDE config), docs (MkDocs), project-api (backend Python with src, data, notebooks, tools), project-ui (frontend), and root-level config files (.gitignore, .pre-commit-config.yaml, docker-compose.yml, Makefile, README.md).
  • Backend/Frontend Separation: Emphasizes separating heavy data processing to the project-api via HTTP requests, keeping the browser UI light.
• Python Toolbox:
  • uv: Used as the primary Python package manager and build tool for dependency installation and management.
  • ruff: A "super-fast" linter and code formatter that combines functionalities of isort, flake8, and autoflake, ensuring clean and maintainable code.
  • ty: An early-development type checker from Astral (creators of uv and ruff) that works with Python's typing module to catch type errors early.
  • pytest: The chosen testing library for Python, praised for its ease of use in writing "simple and scalable test cases," supporting fixtures and parameterized tests.
  • Pydantic: Utilized for data validation and managing application settings (e.g., API keys, database URLs), automatically loading from environment variables or .env files.
  • MkDocs: Used for generating documentation and static websites for projects, with a focus on copying aesthetically pleasing designs.
  • FastAPI: The preferred framework for building RESTful APIs, offering automatic validation, serialization, and documentation, and integrating seamlessly with Pydantic for type safety and performance.
  • Dataclasses: A Python feature that reduces boilerplate when defining classes primarily used to store data by automatically generating __init__(), __repr__(), and __eq__() methods.
• Version Control:
  • GitHub Actions: Favored for CI/CD pipelines across different operating systems, often using Docker to run tests in isolated environments.
  • Dependabot: Automates the process of checking for outdated dependencies and creating pull requests to update them.
  • Gitleaks: A crucial tool for preventing the accidental commitment of sensitive information (like API keys) to repositories.
  • Pre-commit Hooks: Used to run checks (e.g., ruff, gitleaks) and format code automatically before each commit, ensuring adherence to coding standards.
• Infrastructure Management:
  • Make: A "Swiss Army knife" utility used to create simple shortcuts for common development tasks like running tests, building Docker images, or starting services. Separate Makefiles are used for the API and global infrastructure.
  • Docker & Docker Compose: Docker is used to package applications and their dependencies into self-contained containers. Docker Compose is used locally to connect multiple Docker images into a single network, encapsulating the entire application stack and isolating it from the local environment.
  • Low Runtime Example: The example video's runtime analysis is not applicable to a text document.Abstract:

César Soto Valero details his transition to Python for building "production-ready" AI applications, driven by Python's dominance in the AI field and its significant improvements in ecosystem, performance, and syntax over the past decade. He addresses the gap between casual scripting and robust application development by sharing his comprehensive toolkit and methodology. This includes a preference for monorepo project structures, and a curated set of tools for package management (uv), code quality (ruff, ty), testing (pytest), data validation (Pydantic), documentation (MkDocs), API development (FastAPI), and boilerplate reduction (Dataclasses). He also outlines his version control practices leveraging GitHub Actions, Dependabot, Gitleaks, and pre-commit hooks, alongside infrastructure management with Make and Docker/Docker Compose for consistent and deployable applications.

Building Production-Ready Python Apps: A Personal Toolkit

• Switch to Python: The author began coding more seriously in Python about six months prior, driven by the significant opportunities in AI, where Python is the leading language. Previously, Python was used only for small scripts.
• Python's Evolution: Over the past decade, Python has vastly improved its ecosystem, becoming faster with tools like Cython, and refining its syntax to be more developer-friendly.
• Bridging the Gap: There's a notable difference between using Python for quick scripts/notebooks and building "production-ready" applications; this post aims to share tools and methods for the latter.
• Project Structure - Monorepo Preference: The author favors a monorepo structure (backend and frontend) for projects, citing ease of management, reduced scattering of code, and simplified build/deployment processes.
  • A typical monorepo includes dedicated directories for GitHub Actions (.github), VSCode configurations (.vscode), documentation (docs), the backend API (project-api), and the frontend UI (project-ui), along with global configuration files.
  • Heavy data processing is delegated to the backend API (project-api) to keep the frontend UI light.
• Python Toolbox for Development:
  • uv: Used as the primary Python package manager and build tool.
  • ruff: A fast Python linter and code formatter that combines functionalities like isort, flake8, and autoflake to maintain clean code.
  • ty: An early-stage type checker (from Astral, creators of uv and ruff) that works with Python's static typing to catch errors early.
  • pytest: The preferred testing library, lauded for its ease in creating simple and scalable test cases, supporting features like fixtures.
  • Pydantic: Employed for data validation and managing application settings, capable of automatically loading and validating settings from environment variables or .env files.
  • MkDocs: Used for generating project documentation and static websites.
  • FastAPI: The chosen framework for building RESTful APIs, providing automatic validation, serialization, and documentation, and benefiting from its foundation on Starlette and Pydantic for performance and type safety.
  • Dataclasses: A Python feature used to reduce boilerplate code for classes primarily intended for data storage.
• Version Control Best Practices:
  • GitHub Actions: Leveraged for CI/CD pipelines across various operating systems, often utilizing Docker for isolated test environments.
  • Dependabot: Automates the process of identifying and updating outdated dependencies.
  • Gitleaks: Essential for preventing sensitive information (e.g., API keys) from being accidentally committed to the repository.
  • Pre-commit Hooks: Used to run automated checks and code formatting (e.g., ruff, gitleaks) before each commit, ensuring code quality and adherence to standards.
• Infrastructure Management:
  • Make: A classic utility used to create shortcuts for common development commands (e.g., make test, make infrastructure-up), streamlining workflows.
  • Docker & Docker Compose: Docker is used for packaging applications and their dependencies into self-contained containers, ensuring consistent environments. Docker Compose orchestrates multi-container applications locally, isolating the application stack.