35:"/_next/static/chunks/0_6qdgbl18thf.js" 36:"/_next/static/chunks/3316o_1ddm9ab.js" 37:I[96601,["$1","$22","$23","$35","$36"],"default"] 38:I[58709,["$1","$22","$23","$35","$36"],"default"] 39:I[80423,["$1","$22","$23","$35","$36"],"default"] 3a:T455,# Conflict scenario # Package A requires requests>=2.28.0,<2.30.0 # Package B requires requests>=2.31.0 $ pip install package-a # Installs requests==2.29.0 $ pip install package-b # Upgrades to requests==2.31.0 # Package A might break if not compatible # pip doesn't warn about conflicts! # You discover at runtime: ImportError, AttributeError # Check for conflicts $ pip check package-a 1.0.0 has requirement requests<2.30.0, but you have requests 2.31.0 # Solutions: # 1. Find compatible versions $ pip install package-a package-b # pip tries to find versions that work together # 2. Use Poetry (resolves automatically) $ poetry add package-a package-b # Poetry finds compatible versions or fails with clear error # 3. Upgrade Package A $ pip install --upgrade package-a # Hope newer version supports requests 2.31+ # 4. Separate virtual environments (if packages not needed together) $ python3 -m venv venv-a $ source venv-a/bin/activate $ pip install package-a # Uses requests 2.29 $ deactivate $ python3 -m venv venv-b $ source venv-b/bin/activate $ pip install package-b # Uses requests 2.313b:Tdee,# Project Structure: # flask_v2.0/ # ├── venv/ (generated, gitignored) # ├── app.py # ├── requirements.txt # ├── .gitignore # flask_v2.3/ # ├── venv/ # ├── app.py # ├── requirements.txt # ├── .gitignore # flask_v3.0/ # ├── venv/ # ├── app.py # ├── requirements.txt # ├── .gitignore # Setup Steps: # === Flask 2.0 Project === # Windows: cd flask_v2.0 python -m venv venv venv\Scripts\activate pip install Flask==2.0.3 pip freeze > requirements.txt # Mac/Linux: cd flask_v2.0 python3 -m venv venv source venv/bin/activate pip install Flask==2.0.3 pip freeze > requirements.txt # flask_v2.0/app.py from flask import Flask, jsonify import flask app = Flask(__name__) @app.route('/') def home(): return jsonify({ 'message': 'Flask 2.0 Application', 'flask_version': flask.__version__, 'python_version': f"{__import__('sys').version_info.major}.{__import__('sys').version_info.minor}" }) @app.route('/version') def version(): return f"Running Flask {flask.__version__}" if __name__ == '__main__': app.run(debug=True, port=5000) # flask_v2.0/.gitignore venv/ __pycache__/ *.pyc .env # === Flask 2.3 Project === # Repeat setup with Flask==2.3.3 # flask_v2.3/app.py from flask import Flask, jsonify import flask app = Flask(__name__) @app.route('/') def home(): return jsonify({ 'message': 'Flask 2.3 Application', 'flask_version': flask.__version__, 'new_features': 'Flask 2.3 adds improved async support' }) @app.route('/async-example') async def async_route(): # Flask 2.3 has better async support return jsonify({'message': 'Async route in Flask 2.3!'}) if __name__ == '__main__': app.run(debug=True, port=5001) # === Flask 3.0 Project === # Repeat setup with Flask==3.0.0 # flask_v3.0/app.py from flask import Flask, jsonify import flask app = Flask(__name__) @app.route('/') def home(): return jsonify({ 'message': 'Flask 3.0 Application', 'flask_version': flask.__version__, 'new_features': 'Flask 3.0 includes major improvements' }) if __name__ == '__main__': app.run(debug=True, port=5002) # Testing Virtual Environment Isolation: # 1. Activate flask_v2.0 venv: python -c "import flask; print(flask.__version__)" # Output: 2.0.3 # 2. Deactivate and activate flask_v2.3 venv: deactivate cd ../flask_v2.3 source venv/bin/activate # or venv\Scripts\activate on Windows python -c "import flask; print(flask.__version__)" # Output: 2.3.3 # 3. Verify simultaneous execution: # Terminal 1: cd flask_v2.0 source venv/bin/activate python app.py # Runs on port 5000 # Terminal 2: cd flask_v2.3 source venv/bin/activate python app.py # Runs on port 5001 # Terminal 3: cd flask_v3.0 source venv/bin/activate python app.py # Runs on port 5002 # Visit http://localhost:5000, :5001, :5002 - each shows different version! # Testing requirements.txt Recreation: # Backup current venv mv venv venv_backup # Recreate from requirements.txt python -m venv venv source venv/bin/activate # or venv\Scripts\activate pip install -r requirements.txt # Test app still works python app.py # Success! Environment perfectly recreated. # Common Commands Reference: # Windows: python -m venv venv venv\Scripts\activate deactivate pip freeze > requirements.txt pip install -r requirements.txt # Mac/Linux: python3 -m venv venv source venv/bin/activate deactivate pip freeze > requirements.txt pip install -r requirements.txt 3c:Ta3b,# Setup script creating dependency conflict scenario #!/usr/bin/env python3 """ Dependency Conflict Resolution Exercise Scenario: Your project uses: - 'moto' (AWS mock library) requires requests<2.29 - 'responses' (HTTP mock library) version 0.23.0 requires requests>=2.30 This creates an impossible situation - pip cannot satisfy both. """ import subprocess import sys def setup_conflict_environment(): """Create venv and install conflicting packages""" print('Setting up environment with dependency conflict...') # Install packages that will conflict packages = [ 'moto==4.0.0', # Requires requests<2.29 'responses==0.23.0' # Requires requests>=2.30 ] for package in packages: print(f'\nInstalling {package}...') subprocess.run([sys.executable, '-m', 'pip', 'install', package]) # Check for conflicts print('\n=== Running pip check ===') result = subprocess.run( [sys.executable, '-m', 'pip', 'check'], capture_output=True, text=True ) print(result.stdout) if result.returncode != 0: print('\n❌ CONFLICT DETECTED!') print(result.stdout) def analyze_dependency_tree(): """Use pipdeptree to understand conflict""" print('\n=== Dependency Tree Analysis ===') # TODO: Install pipdeptree if not present # TODO: Run pipdeptree to show full dependency graph # TODO: Highlight conflicting package (requests) pass def find_compatible_versions(): """Research and test compatible version combinations""" print('\n=== Testing Compatible Versions ===') # Strategy 1: Update moto to newer version # Check if moto>=4.1.0 supports requests>=2.30 # Strategy 2: Downgrade responses # Check if responses<0.23.0 supports requests<2.29 # Strategy 3: Pin requests to overlapping range # Find if there's a requests version both accept # TODO: Try each strategy, run tests pass def verify_resolution(): """Verify conflict is resolved and functionality works""" # TODO: Run pip check (should pass) # TODO: Import both packages (should work) # TODO: Run functionality tests for both pass # TODO: Create conflict-resolution.md documenting: # - Initial conflict description # - Packages and versions involved # - Dependency tree analysis # - Attempted solutions (what worked, what didn't) # - Final working resolution # - Prevention strategies if __name__ == '__main__': setup_conflict_environment() analyze_dependency_tree() find_compatible_versions() verify_resolution()3d:T423,Mastery of systematic dependency conflict resolution. Complete understanding of conflict detection: pip check identifies issues, pipdeptree reveals dependency chains causing conflicts. Practical resolution strategies: (1) update packages to versions with relaxed requirements, (2) downgrade to versions with compatible requirements, (3) pin to overlapping version range, (4) replace with alternative packages. Professional documentation: conflict-resolution.md explaining problem, attempted solutions, final resolution - essential for team knowledge sharing. Automated prevention: script running pip check after every install catches conflicts immediately. Recognition that dependency conflicts are common in real projects (not just academic exercise): numpy/pandas, Django/Django-extensions, pytest plugins all have version conflicts in wild. This skill prevents 'works on my machine' problems: your careful resolution ensures everyone gets compatible versions. Essential for maintaining production applications where dependency updates can break everything.3e:T1a19,# Migration Guide and Scripts #!/usr/bin/env python3 """ Migrate Python Project from pip to Poetry Project Structure: ├── app.py # Flask application ├── requirements.txt # Current pip dependencies ├── requirements-dev.txt # Development dependencies ├── venv/ # Old virtual environment └── tests/ # Test suite After Migration: ├── pyproject.toml # Poetry config with dependencies ├── poetry.lock # Locked versions (like package-lock.json) ├── .venv/ # Poetry-managed virtualenv └── requirements.txt # Exported for Docker/deployment """ import subprocess import os from pathlib import Path def check_poetry_installed(): """Verify Poetry is installed""" try: result = subprocess.run(['poetry', '--version'], capture_output=True, text=True) print(f'✓ Poetry installed: {result.stdout.strip()}') return True except FileNotFoundError: print('✗ Poetry not found. Install with:') print(' curl -sSL https://install.python-poetry.org | python3 -') return False def backup_existing_setup(): """Backup current pip setup""" print('\n=== Backing up existing setup ===') # TODO: Copy requirements.txt to requirements-old.txt # TODO: Document current Python version and venv location pass def initialize_poetry(): """Run poetry init interactively""" print('\n=== Initializing Poetry ===') print('Answer prompts to create pyproject.toml') # TODO: Run 'poetry init' (interactive) # Or create pyproject.toml programmatically: pyproject_content = """ [tool.poetry] name = "my-flask-app" version = "0.1.0" description = "Flask application migrated to Poetry" authors = ["Your Name "] readme = "README.md" packages = [{include = "app"}] [tool.poetry.dependencies] python = "^3.11" # Dependencies will be added below [tool.poetry.group.dev.dependencies] # Dev dependencies will be added below [build-system] requires = ["poetry-core"] build-backend = "poetry.core.masonry.api" """ # TODO: Write to pyproject.toml pass def migrate_dependencies(): """Convert requirements.txt to Poetry dependencies""" print('\n=== Migrating dependencies ===') # Read requirements.txt with open('requirements.txt') as f: requirements = [line.strip() for line in f if line.strip() and not line.startswith('#')] print(f'Found {len(requirements)} dependencies to migrate') for req in requirements: # Parse requirement: flask==2.3.0 -> package=flask, version==2.3.0 # TODO: Extract package name and version specifier # TODO: Run 'poetry add package@version' print(f' Migrating: {req}') # Migrate dev dependencies print('\nMigrating development dependencies...') dev_deps = ['pytest', 'black', 'flake8', 'mypy', 'pytest-cov'] for dep in dev_deps: # TODO: Run 'poetry add --group dev {dep}' pass def generate_lock_file(): """Generate poetry.lock with resolved dependencies""" print('\n=== Generating poetry.lock ===') # TODO: Run 'poetry lock' # This resolves full dependency tree and creates lock file pass def verify_migration(): """Test that migrated environment works""" print('\n=== Verifying migration ===') # Install dependencies in new Poetry venv # TODO: Run 'poetry install' # Run tests # TODO: Run 'poetry run pytest' # Try importing main app # TODO: Run 'poetry run python -c "import app; print(app.app.name)"' print('✓ Migration successful!') def export_for_deployment(): """Export requirements.txt for Docker/legacy systems""" print('\n=== Exporting requirements.txt ===') # TODO: Run 'poetry export -f requirements.txt --output requirements.txt --without-hashes' print('✓ requirements.txt exported for deployment') def create_poetry_guide(): """Document Poetry workflow for team""" guide = """ # Poetry Migration Guide ## Why Poetry? - **Lock files**: poetry.lock ensures everyone has exact same versions - **Better dependency resolution**: handles conflicts automatically - **Dev dependencies**: separate dev/test tools from production deps - **Virtual environment**: manages venv automatically ## Common Commands ### Installation ```bash poetry install # Install all dependencies poetry install --no-dev # Production dependencies only ``` ### Adding Dependencies ```bash poetry add flask # Add production dependency poetry add --group dev pytest # Add dev dependency poetry add 'requests>=2.28,<3.0' # Add with version constraint ``` ### Running Commands ```bash poetry run python app.py # Run script in Poetry venv poetry run pytest # Run tests poetry shell # Activate venv shell ``` ### Updating ```bash poetry update # Update all dependencies poetry update requests # Update specific package poetry show --outdated # Check for updates ``` ### Deployment ```bash poetry export -f requirements.txt --output requirements.txt --without-hashes # Use exported requirements.txt in Dockerfile ``` ## Troubleshooting ### Conflict Resolution Poetry's resolver handles most conflicts automatically. If issues arise: ```bash poetry lock --no-update # Regenerate lock without updating poetry cache clear pypi --all # Clear cache ``` ### Python Version Specify in pyproject.toml: ```toml [tool.poetry.dependencies] python = "^3.11" # Requires Python 3.11+ ``` ## When to Use Poetry vs pip **Use Poetry when:** - Building library to publish on PyPI - Complex dependency trees with potential conflicts - Team project needing reproducible environments - Managing multiple dependency groups (dev, test, docs) **Use pip when:** - Simple scripts with few dependencies - Deploying to constrained environments (AWS Lambda) - Legacy projects with established pip workflow - Quick prototypes """ # TODO: Write to POETRY_GUIDE.md pass if __name__ == '__main__': if not check_poetry_installed(): exit(1) backup_existing_setup() initialize_poetry() migrate_dependencies() generate_lock_file() verify_migration() export_for_deployment() create_poetry_guide() print('\n=== Migration Complete! ===') print('Next steps:') print('1. Commit pyproject.toml and poetry.lock') print('2. Update CI/CD to use Poetry') print('3. Share POETRY_GUIDE.md with team') print('4. Delete old venv directory')3f:T49a,Complete migration from pip to Poetry with modern dependency management. Understanding of Poetry's advantages: poetry.lock provides reproducibility superior to requirements.txt (includes full dependency tree with hashes, not just direct dependencies), automatic conflict resolution using SAT solver (pip often fails with version conflicts), separate dependency groups (dev, test, docs without polluting production), integrated virtual environment management (no manual venv creation). Hands-on experience: migrating real project, separating prod/dev dependencies, generating lock files, exporting for deployment. Professional documentation: POETRY_GUIDE.md teaching team Poetry workflow, common commands, troubleshooting, when Poetry adds value vs overkill. Critical thinking: understanding trade-offs between pip and Poetry - Poetry excellent for libraries and complex apps, pip sufficient for simple scripts and deployment. Recognition that Poetry is industry standard for Python libraries (requests, httpx, FastAPI all use Poetry) and gaining adoption for applications. This demonstrates senior judgment: you evaluate tools based on project needs, not just 'use latest tool'.29:["$","div",null,{"className":"min-h-screen bg-gray-50 dark:bg-gray-900 pt-20","children":[["$","$L37",null,{"topicSlug":"python","topicTitle":"Python Engineer's Expedition","dayNumber":59,"dayTitle":"Virtual Environments and Dependency Management","sprintNumber":3,"estimatedTime":"3 hours","totalDays":66}],["$","div",null,{"className":"w-full px-4 sm:px-6 lg:px-8 py-8","children":["$","$L38",null,{"dayNumber":59,"topicSlug":"python","children":["$","$L39",null,{"day":{"sprintNumber":3,"dayNumber":59,"title":"Virtual Environments and Dependency Management","subtitle":"Master dependency isolation and reproducible environments","description":"Master Python virtual environments, dependency management, and project isolation. Learn venv, pip, requirements.txt, Poetry, and best practices for reproducible development environments used by professional teams.","learningGoals":[{"id":"goal-59-1","text":"Understand why virtual environments are essential for Python projects","measurable":"Explain dependency isolation and demonstrate creating project-specific environments"},{"id":"goal-59-2","text":"Create and manage virtual environments with venv and virtualenv","measurable":"Set up 3+ projects with isolated virtual environments and activate/deactivate properly"},{"id":"goal-59-3","text":"Master pip: install, uninstall, freeze, and requirements.txt","measurable":"Generate requirements.txt with pinned versions and recreate environment from it"},{"id":"goal-59-4","text":"Use Poetry for modern dependency management with lock files","measurable":"Create Poetry project with dev dependencies and understand pyproject.toml + poetry.lock"},{"id":"goal-59-5","text":"Handle dependency conflicts and version pinning","measurable":"Resolve conflicting package versions using pip check and Poetry's resolver"},{"id":"goal-59-6","text":"Set up reproducible environments for team collaboration and deployment","measurable":"Create Docker environment where 'docker-compose up' runs complete development stack"}],"whyThisMatters":{"productionStory":"At Spotify, engineers work on 50+ Python microservices simultaneously. Without virtual environments, installing pandas 1.5 for Service A would break Service B requiring pandas 1.3. Virtual environments isolate dependencies per project. When deploying to production, requirements.txt ensures exact same dependencies locally and in production. No 'works on my machine' surprises. Virtual environments are foundation of professional Python development.","realWorldContext":"You clone a repository. Run python app.py and see: 'ModuleNotFoundError: No module named requests'. Without requirements.txt, you don't know what to install. Professional projects include requirements.txt or pyproject.toml documenting all dependencies. One command - pip install -r requirements.txt - sets up complete environment. Virtual environments enable reproducibility: everyone has same versions, locally and in production.","industryRelevance":"Job interview question: 'How do you manage Python dependencies?' Answer: 'Virtual environments with venv, pip freeze for requirements.txt, and Poetry for complex projects with lock files.' Companies expect this knowledge. Projects without virtual environments are amateur hour. This skill is non-negotiable for professional Python developers."},"missionAlignment":{"empowerLearners":"Virtual environments unlock ability to work on multiple Python projects without conflicts. Work on Django 3 project and Django 4 project on same machine. This is how professionals work - you'll never break one project by installing dependencies for another.","expertiseInFocus":"Dependency management is professional skill. You'll learn what companies use: venv for simplicity, Poetry for complex projects, pip freeze for deployments. Know when to use each tool and why.","realWorldPreparation":"Every Python job uses virtual environments. First day at company: clone repo, create venv, pip install -r requirements.txt, run tests. This workflow is universal across industry."},"coreValues":{"practiceFirst":"You'll create 5+ virtual environments for different projects. Practice dependency conflicts and resolution.","masteryOriented":"Understand internals: how venv modifies PATH, how pip installs packages, how Poetry resolves dependency trees.","buildInPublic":"Your GitHub repos will include proper requirements.txt or pyproject.toml - demonstrating professional practices."},"topics":["Virtual Environments (venv)","pip and Package Management","requirements.txt Best Practices","Poetry for Modern Dependency Management","Dependency Conflicts","Docker for Reproducibility"],"coreContent":{"sections":[{"id":"section-1","type":"concept","title":"Why Virtual Environments Are Essential","order":1,"content":{"explanation":"Without virtual environments, all Python packages install globally. Installing Django 4 for Project A breaks Project B using Django 3. Virtual environments isolate dependencies per project. Each project has own Python interpreter and packages. This prevents conflicts and enables reproducibility.","codeExamples":[{"title":"The Problem: Global Package Hell","code":"# WITHOUT virtual environments - DISASTER\n\n# Working on Project A (Django 3)\n$ pip install django==3.2.0\n# Works fine, Project A runs\n\n# Now work on Project B (Django 4)\n$ pip install django==4.2.0\n# This UPGRADES Django globally\n# Project A now BROKEN - import errors, API changes\n\n# Problem: Both projects share same Python installation\n# Installing packages for one project affects all projects\n# Team members have different versions\n# Production environment different from local\n# \"Works on my machine\" syndrome","language":"bash","explanation":"Global installs create conflicts. You cannot have Django 3 and Django 4 simultaneously."},{"title":"The Solution: Virtual Environments","code":"# WITH virtual environments - PROFESSIONAL\n\n# Project A - isolated environment\n$ cd project-a\n$ python3 -m venv venv\n$ source venv/bin/activate\n(venv) $ pip install django==3.2.0\n(venv) $ python manage.py runserver # Works\n(venv) $ deactivate\n\n# Project B - separate isolated environment\n$ cd project-b\n$ python3 -m venv venv\n$ source venv/bin/activate\n(venv) $ pip install django==4.2.0\n(venv) $ python manage.py runserver # Works\n\n# Both projects work simultaneously\n# Each has own Django version\n# No conflicts","language":"bash","explanation":"Virtual environments isolate dependencies. Each project has own packages without conflicts."}]}},{"id":"section-2","type":"concept","title":"Creating and Managing Virtual Environments","order":2,"content":{"explanation":"venv is built into Python 3.3+. Creates lightweight isolated Python environment. Activating venv modifies PATH to use venv's Python. Deactivating restores original PATH. Convention: name venv 'venv' or '.venv'.","codeExamples":[{"title":"Complete venv Workflow","code":"# Create new project with virtual environment\n$ mkdir my-project\n$ cd my-project\n\n# Create virtual environment named 'venv'\n$ python3 -m venv venv\n\n# What this creates:\n# venv/\n# bin/ # Python interpreter, pip, activate scripts\n# lib/ # Installed packages\n# include/ # C headers\n# pyvenv.cfg # Config\n\n# Activate virtual environment\n$ source venv/bin/activate # macOS/Linux\n$ venv\\Scripts\\activate # Windows\n\n# Prompt changes to show active venv\n(venv) $\n\n# Now 'python' and 'pip' use venv versions\n(venv) $ which python\n/Users/you/my-project/venv/bin/python\n\n(venv) $ python --version\nPython 3.11.0\n\n# Install packages - only available in this venv\n(venv) $ pip install requests flask\n\n# Run your code\n(venv) $ python app.py\n\n# Deactivate when done\n(venv) $ deactivate\n$ # Prompt returns to normal","language":"bash","explanation":"Standard workflow: create venv, activate, install packages, work, deactivate. Simple and effective."},{"title":"venv vs virtualenv vs conda","code":"# venv (built-in, Python 3.3+)\n$ python3 -m venv venv\n# Pros: Built-in, fast, lightweight\n# Cons: Only Python packages\n# Use for: Most Python projects\n\n# virtualenv (third-party, more features)\n$ pip install virtualenv\n$ virtualenv venv\n# Pros: Works with Python 2, faster than venv\n# Cons: Need to install separately\n# Use for: Legacy Python 2 projects\n\n# conda (Anaconda, handles non-Python deps)\n$ conda create -n myenv python=3.11\n$ conda activate myenv\n# Pros: Manages Python + C libraries, data science packages\n# Cons: Large, slower, complex\n# Use for: Data science with NumPy, Pandas, scikit-learn","language":"bash","explanation":"venv for most projects. virtualenv for Python 2. conda for data science."}]}},{"id":"section-3","type":"concept","title":"pip and requirements.txt","order":3,"content":{"explanation":"pip is Python package manager. requirements.txt lists project dependencies. pip freeze captures current environment. requirements.txt enables reproducibility: anyone can recreate exact environment with pip install -r requirements.txt.","codeExamples":[{"title":"Creating and Using requirements.txt","code":"# Install packages for your project\n(venv) $ pip install flask==2.3.0 requests==2.31.0 python-dotenv==1.0.0\n\n# Capture all installed packages with versions\n(venv) $ pip freeze > requirements.txt\n\n# requirements.txt contents:\nflask==2.3.0\nrequests==2.31.0\npython-dotenv==1.0.0\nclick==8.1.3 # Flask dependency\nWerkzeug==2.3.0 # Flask dependency\n# ... all dependencies and sub-dependencies\n\n# Now anyone can recreate environment:\n$ python3 -m venv venv\n$ source venv/bin/activate\n(venv) $ pip install -r requirements.txt\n# Installs exact same versions\n\n# Update package\n(venv) $ pip install --upgrade flask\n(venv) $ pip freeze > requirements.txt # Update file","language":"bash","explanation":"pip freeze captures exact versions. requirements.txt ensures reproducibility across team and production."},{"title":"requirements.txt Best Practices","code":"# ❌ BAD: No version pinning\nflask\nrequests\npandas\n# Problem: pip install installs latest versions\n# Different versions for different developers\n# Production might have different versions\n# Bugs appear in production, not locally\n\n# ❌ BAD: Too loose\nflask>=2.0.0\nrequests>=2.28.0\n# Problem: Major version upgrades might break code\n\n# ✅ GOOD: Pin exact versions\nflask==2.3.0\nrequests==2.31.0\npandas==2.0.3\n# Everyone gets exact same versions\n# Reproducible builds\n\n# ✅ BETTER: Separate dev and prod dependencies\n# requirements.txt (production)\nflask==2.3.0\nrequests==2.31.0\n\n# requirements-dev.txt (development)\n-r requirements.txt # Include production deps\npytest==7.4.0\npytest-cov==4.1.0\nruff==0.0.286\nmypy==1.5.0\n\n# Install dev dependencies\n(venv) $ pip install -r requirements-dev.txt","language":"python","explanation":"Always pin exact versions. Separate production and development dependencies."}]}},{"id":"section-4","type":"concept","title":"Poetry: Modern Dependency Management","order":4,"content":{"explanation":"Poetry is modern dependency manager: handles dependencies, virtual environments, and packaging. pyproject.toml defines project metadata and dependencies. poetry.lock locks exact versions (like package-lock.json in npm). Poetry resolves dependency conflicts automatically.","codeExamples":[{"title":"Getting Started with Poetry","code":"# Install Poetry\n$ curl -sSL https://install.python-poetry.org | python3 -\n\n# Create new project\n$ poetry new my-project\n$ cd my-project\n\n# Project structure:\n# my-project/\n# pyproject.toml # Project config and dependencies\n# poetry.lock # Locked versions (auto-generated)\n# my_project/ # Source code\n# tests/ # Tests\n\n# pyproject.toml:\n[tool.poetry]\nname = \"my-project\"\nversion = \"0.1.0\"\ndescription = \"\"\nauthors = [\"Your Name \"]\n\n[tool.poetry.dependencies]\npython = \"^3.11\"\n\n[tool.poetry.dev-dependencies]\npytest = \"^7.4.0\"\n\n# Add dependencies\n$ poetry add requests flask\n# Adds to pyproject.toml and poetry.lock\n\n# Add dev dependencies\n$ poetry add --group dev pytest pytest-cov\n\n# Install all dependencies\n$ poetry install\n\n# Run commands in venv\n$ poetry run python app.py\n$ poetry run pytest\n\n# Activate shell with venv\n$ poetry shell","language":"bash","explanation":"Poetry handles dependency resolution, virtual environments, and packaging. Modern workflow."},{"title":"Poetry vs pip + venv","code":"# pip + venv (traditional)\n$ python3 -m venv venv\n$ source venv/bin/activate\n$ pip install flask requests\n$ pip freeze > requirements.txt\n# Pros: Simple, built-in, universal\n# Cons: Manual venv management, no lock file, no dependency resolution\n\n# Poetry (modern)\n$ poetry new myproject\n$ poetry add flask requests\n$ poetry install\n# Pros: Automatic venv, lock file, dependency resolution, packaging\n# Cons: Extra tool to install, learning curve\n\n# When to use Poetry:\n- Building libraries for PyPI\n- Complex dependency trees\n- Team projects needing reproducibility\n- When you want modern workflow\n\n# When to use pip + venv:\n- Simple scripts\n- Legacy projects\n- When Poetry not available\n- Deployment to serverless (smaller size)","language":"python","explanation":"Poetry for modern projects. pip+venv for simplicity or legacy compatibility."}]}},{"id":"section-5","type":"concept","title":"Handling Dependency Conflicts","order":5,"content":{"explanation":"Dependency conflicts occur when Package A requires library X version 1, but Package B requires library X version 2. pip doesn't resolve conflicts - last install wins. Poetry and pip-tools resolve conflicts. Solutions: upgrade packages, find compatible versions, use virtual environments to isolate.","codeExamples":[{"title":"Dependency Conflict Example","code":"$3a","language":"bash","explanation":"Dependency conflicts are common. Poetry auto-resolves. With pip, check manually and test thoroughly."},{"title":"Dependency Resolution Tools","code":"# pip-tools: Compile requirements with dependency resolution\n$ pip install pip-tools\n\n# Create requirements.in (high-level deps)\nflask\nrequests\npandas\n\n# Compile to requirements.txt (all deps with resolved versions)\n$ pip-compile requirements.in\n# Creates requirements.txt with exact versions and all sub-dependencies\n\n# Install exact versions\n$ pip-sync requirements.txt\n# Installs exact versions, removes anything not listed\n\n# Benefits:\n- Dependency resolution like Poetry\n- Lock file (requirements.txt)\n- Works with existing pip workflow\n- Smaller than Poetry for deployment","language":"bash","explanation":"pip-tools adds dependency resolution to pip. Good middle ground between pip and Poetry."}]}},{"id":"section-6","type":"concept","title":"Docker for Ultimate Reproducibility","order":6,"content":{"explanation":"Virtual environments isolate Python packages but not system dependencies (C libraries, database drivers). Docker containers isolate entire operating system: Python version, system packages, environment variables. Dockerfile defines exact environment. Same container runs locally and in production - true reproducibility.","codeExamples":[{"title":"Dockerfile for Python Application","code":"# Dockerfile\nFROM python:3.11-slim\n\n# Set working directory\nWORKDIR /app\n\n# Install system dependencies (if needed)\nRUN apt-get update && apt-get install -y \\\n gcc \\\n postgresql-client \\\n && rm -rf /var/lib/apt/lists/*\n\n# Copy requirements first (for caching)\nCOPY requirements.txt .\n\n# Install Python dependencies\nRUN pip install --no-cache-dir -r requirements.txt\n\n# Copy application code\nCOPY . .\n\n# Run application\nCMD [\"python\", \"app.py\"]\n\n# Build image\n$ docker build -t myapp:latest .\n\n# Run container\n$ docker run -p 8000:8000 myapp:latest\n\n# Same image runs on:\n- Developer laptop (macOS, Windows, Linux)\n- CI/CD pipeline\n- Production servers\n- Teammate's machine\n# Exact same environment everywhere","language":"dockerfile","explanation":"Docker ensures true reproducibility: same OS, Python, packages, system dependencies everywhere."},{"title":"Docker Compose for Development","code":"# docker-compose.yml\nversion: '3.8'\n\nservices:\n app:\n build: .\n ports:\n - \"8000:8000\"\n volumes:\n - .:/app # Mount code for hot reload\n environment:\n - DATABASE_URL=postgresql://postgres:password@db:5432/mydb\n depends_on:\n - db\n \n db:\n image: postgres:15\n environment:\n - POSTGRES_PASSWORD=password\n - POSTGRES_DB=mydb\n volumes:\n - postgres_data:/var/lib/postgresql/data\n\nvolumes:\n postgres_data:\n\n# Start entire stack\n$ docker-compose up\n\n# Python app + PostgreSQL database\n# Team members run exact same environment\n# No \"works on my machine\" issues","language":"yaml","explanation":"Docker Compose orchestrates multiple containers. Entire development environment in one command."}]}}]},"videoResources":{"primary":{"title":"Python Tutorial: VENV (Windows) - How to Use Virtual Environments with the Built-In venv Module","creator":"Corey Schafer","embedId":"APOPm01BVrk","duration":"6:43","description":"⭐ Essential guide to Python virtual environments on Windows. Corey explains why virtual environments prevent dependency conflicts, how to create venv, activate/deactivate commands, installing packages in isolated environments, and using requirements.txt. Perfect length for understanding complete venv workflow. Every Python developer needs this foundation.","when":"MUST WATCH - Complete foundation for virtual environments on Windows"},"secondary":{"title":"Python Tutorial: VENV (Mac & Linux) - How to Use Virtual Environments with the Built-In venv Module","creator":"Corey Schafer","embedId":"Kg1Yvry_Ydk","duration":"12:47","description":"Complete venv guide for Mac and Linux users. Covers creating virtual environments, activating with source command, managing dependencies with pip, requirements.txt workflow, and .gitignore best practices. Shows practical examples of working with multiple projects. Cross-platform developers should watch both videos.","when":"Watch if you're on Mac/Linux or need complete venv understanding"}},"challenges":[{"id":"challenge-59-1","difficulty":"basecamp","title":"Master Virtual Environment Creation and Management","description":"Create 3 separate Flask projects using different Flask versions (2.0, 2.3, 3.0) in isolated virtual environments. Learn why dependency isolation prevents conflicts, how to activate/deactivate venvs, generate requirements.txt, and run multiple projects simultaneously without version conflicts.","requirements":["Create 3 project directories: flask_v2.0/, flask_v2.3/, flask_v3.0/","In flask_v2.0/: create venv, install Flask==2.0.3, create simple app.py with /version route","In flask_v2.3/: create venv, install Flask==2.3.3, create app.py with new Flask 2.3 features","In flask_v3.0/: create venv, install Flask==3.0.0, create app.py with Flask 3 features","Generate requirements.txt for each project using pip freeze","Add .gitignore to each project excluding venv/ directories","Run all 3 Flask apps simultaneously on different ports (5000, 5001, 5002)","Verify each app shows correct Flask version","Document activation commands for each OS (Windows/Mac/Linux)","Test recreating environments from requirements.txt: delete venv, recreate, verify works"],"starterCode":"$3b","hints":["Create venv: python -m venv venv (or python3 -m venv venv on Mac/Linux)","Activate Windows: venv\\Scripts\\activate, Mac/Linux: source venv/bin/activate","Verify active venv: which python (Mac/Linux) or where python (Windows)","pip freeze captures ALL installed packages with exact versions","Always activate venv before pip install - installs go to venv, not global Python","Deactivate: just run 'deactivate' command in any venv","Different Flask versions have different APIs - 2.0 vs 3.0 have breaking changes",".gitignore must include venv/ - never commit virtual environments","Run apps on different ports to avoid 'Address already in use' error","Test recreation: rm -rf venv (delete), recreate with requirements.txt, verify works"],"expectedOutcome":"Complete mastery of virtual environment workflow. Three working Flask projects with different versions running simultaneously without conflicts - proving virtual environments provide perfect isolation. Understanding of why venvs are essential: prevents 'works on my machine' problems, enables multiple Python versions per project, isolates dependencies to avoid global pollution. Professional workflow: create venv → activate → install packages → pip freeze → .gitignore venv/ → commit requirements.txt. Ability to recreate any environment from requirements.txt on any machine. Recognition that this is foundation of professional Python development - every project needs isolated environment."},{"id":"challenge-59-2","title":"Resolve Dependency Conflict Between Packages","difficulty":"intermediate","estimatedTime":"45 minutes","description":"Debug and resolve real-world dependency conflicts where Package A requires requests<2.30 but Package B requires requests>=2.31. Learn systematic approach: use pip check to identify conflicts, analyze dependency trees with pipdeptree, find compatible versions, and test that resolution maintains all functionality. Master essential skill for maintaining production applications.","requirements":["Create virtual environment and install packages with conflicting dependencies: 'package-a' (requires requests<2.30) and 'package-b' (requires requests>=2.31)","Run 'pip check' to identify dependency conflicts and understand error messages","Use 'pipdeptree' to visualize complete dependency tree and find where conflicts originate","Research compatible versions: check package changelogs to find versions with overlapping requirements","Test resolution strategies: (1) Update package-a to version accepting requests>=2.31, (2) Downgrade package-b to version accepting requests<2.30, (3) Find alternative packages","Document conflict in conflict-resolution.md: packages involved, conflict reason, tried solutions, final working solution","Verify resolution: run pip check (should pass), run tests for both packages (functionality preserved)","Generate clean requirements.txt with resolved versions pinned","Create script automate_conflict_check.py that runs pip check and pipdeptree after every pip install","Test edge case: Add third package (package-c) also requiring specific requests version, resolve 3-way conflict"],"starterCode":"$3c","hints":["'pip check' shows all dependency conflicts: 'package-a requires requests<2.30 but you have requests 2.31'","'pipdeptree' visualizes full dependency tree: see which packages depend on conflicting versions","Check package release notes on PyPI: search for version that relaxed strict version requirement","Sometimes conflict resolution requires updating multiple packages: A and B both need newer versions","Use version specifiers strategically: 'requests>=2.28,<2.32' might satisfy both packages","Test resolution thoroughly: pip check passes but functionality might break with different versions","Document conflicts in README so teammates know why specific versions are pinned","Consider using Poetry instead of pip - better dependency resolver handles conflicts automatically","If no compatible versions exist, you might need alternative package: replace package-a with package-c","Prevention: regularly run 'pip list --outdated' and update before conflicts become blockers"],"expectedOutcome":"$3d","skills":["Dependency resolution","pip check","Version compatibility","Debugging"]},{"id":"challenge-59-3","title":"Migrate Project from pip to Poetry for Modern Dependency Management","difficulty":"intermediate","estimatedTime":"60 minutes","description":"Migrate existing Flask/FastAPI project from pip/requirements.txt to Poetry for superior dependency management. Learn Poetry's advantages: automatic virtual environment management, lock files for reproducibility, separate dev dependencies, better dependency resolution. Understand when Poetry adds value vs when pip is sufficient.","requirements":["Take existing project with requirements.txt (Flask app with 10+ dependencies) and manual venv","Install Poetry: 'curl -sSL https://install.python-poetry.org | python3 -' (or pipx install poetry)","Initialize Poetry in project: 'poetry init' creating pyproject.toml with project metadata","Convert requirements.txt to Poetry format: 'poetry add $(cat requirements.txt)' or manual migration","Separate production and dev dependencies: poetry add --group dev pytest black flake8 mypy","Generate poetry.lock file with exact dependency versions and full dependency tree","Remove old venv and requirements.txt (keep as requirements-old.txt backup)","Configure poetry to create virtualenv in project directory: 'poetry config virtualenvs.in-project true'","Run all tests with Poetry: 'poetry run pytest' (validates migration successful)","Document Poetry workflow in POETRY_GUIDE.md: installation, adding deps, running commands, common issues","Export to requirements.txt for deployment: 'poetry export -f requirements.txt --output requirements.txt --without-hashes'","Compare: Create table showing pip vs Poetry for dependency resolution, lock files, dev deps, ease of use"],"starterCode":"$3e","hints":["'poetry init' creates pyproject.toml interactively - answer prompts about project name, version, dependencies","'poetry add package' automatically updates pyproject.toml and poetry.lock - no manual editing needed","poetry.lock contains full dependency tree with hashes - commit to git for reproducibility","'poetry config virtualenvs.in-project true' creates .venv/ in project (like npm's node_modules)","'poetry install' reads poetry.lock and installs exact versions - guaranteed reproducibility","Separate dev deps: 'poetry add --group dev pytest' keeps testing tools out of production","'poetry export' generates requirements.txt for Docker/AWS Lambda where Poetry isn't available","Poetry resolves conflicts better than pip: uses SAT solver to find compatible versions","Migration gotcha: some packages have different names on PyPI vs import: 'poetry add pillow' but 'import PIL'","When to skip Poetry: simple scripts, AWS Lambda (Poetry too heavy), legacy teams resistant to change"],"expectedOutcome":"$3f","skills":["Poetry","Migration","pyproject.toml","Dependency management","Tool evaluation"]}],"practiceProjects":[{"id":"project-59-1","title":"Docker-Based Development Environment","difficulty":"advanced","estimatedTime":"3 hours","description":"Create Docker development environment for Flask API + PostgreSQL + Redis. Include: Dockerfile, docker-compose.yml, volume mounts for hot reload, environment variables, health checks. Document setup in README for team onboarding.","skills":["Docker","docker-compose","Environment configuration","DevOps"],"successCriteria":["docker-compose up starts entire stack in one command","Code changes reload automatically (hot reload)","PostgreSQL data persists across restarts","Environment variables configured properly","README with clear setup instructions","Team member can run locally in under 5 minutes"]}],"commonPitfalls":[{"id":"day59-pitfall-1","title":"Committing venv/ directory to Git","howToFix":["Add 'venv/' to .gitignore immediately","Never commit virtual environment directories","Commit requirements.txt or pyproject.toml instead","Team members create own virtual environments","Virtual environments are local, not shared"],"whyItHappens":"Beginners commit venv/ thinking it helps teammates. But venv/ contains 1000+ files, platform-specific binaries. Repository bloats to 100+ MB. Instead, commit requirements.txt - teammates run pip install -r requirements.txt to create own venv."},{"id":"day59-pitfall-2","title":"Not pinning package versions - 'it works on my machine'","howToFix":["Always use pip freeze > requirements.txt to pin exact versions","Never use 'requests' without version in requirements.txt","Pin major.minor.patch: requests==2.31.0","Test with exact versions before deploying","Update requirements.txt when upgrading packages"],"whyItHappens":"Developers write 'flask' in requirements.txt without version. Installs Flask 2.3 locally. Month later, teammate installs Flask 3.0 (new release). Code breaks due to API changes. Production deploys Flask 3.0 - outage. Pin versions for reproducibility."},{"id":"day59-pitfall-3","title":"Installing packages without active virtual environment","howToFix":["Always activate venv before pip install: source venv/bin/activate","Check prompt shows (venv) before installing","Use 'which python' to verify using venv Python","If installed globally by accident, create venv and reinstall","Configure IDE to use venv Python interpreter"],"whyItHappens":"Developers forget to activate venv. Run pip install flask - installs to global Python. Pollutes global environment, doesn't help current project. Later, activate venv and code fails - dependencies not in venv. Always activate before installing."},{"id":"day59-pitfall-4","title":"Not separating dev and production dependencies","howToFix":["Create requirements.txt for production dependencies","Create requirements-dev.txt for development tools","Production doesn't need pytest, ruff, mypy","Use 'pip install -r requirements-dev.txt' locally","Deploy only production dependencies to reduce image size"],"whyItHappens":"Developers put pytest, mypy, ruff in requirements.txt. Production installs these unnecessarily - larger Docker images, slower deployments, security surface. Separate concerns: requirements.txt = production, requirements-dev.txt = development."}],"connections":{"previous":{"content":"You built a production API client (Day 58). Now you need to manage its dependencies and ensure others can install it.","prerequisites":"Day 45 (pytest) and Day 48 (type hints) introduced dev dependencies. Understanding separation of concerns is key."},"current":{"keyTakeaways":["Virtual environments isolate dependencies per project—essential for professional development","pip freeze creates requirements.txt for reproducible installations","Poetry provides modern dependency management with automatic resolution and lock files","Never commit your venv/ folder—requirements.txt or pyproject.toml is the source of truth","Docker ensures identical environments across local, staging, and production"]},"next":{"preview":"Tomorrow you'll learn professional project structure and how to publish packages to PyPI.","teaser":"Your venv is set up. Dependencies are managed. But how do you structure and distribute your package?"}},"reflectionQuestions":[{"id":"day59-reflect-1","question":"Why do companies use Docker instead of just virtual environments? What does Docker provide that venv doesn't?","purpose":"Understand that venv isolates Python packages but Docker isolates entire OS - system dependencies, environment variables, Python version itself"},{"id":"day59-reflect-2","question":"When would you choose Poetry over pip+venv? When would pip+venv be better?","purpose":"Recognize trade-offs: Poetry better for complex projects, libraries, teams; pip+venv better for simple scripts, legacy, deployment size"},{"id":"day59-reflect-3","question":"What happens if you don't pin package versions in requirements.txt? Why is this dangerous for production?","purpose":"Understand that unpinned versions cause 'works on my machine' bugs - different versions locally vs production leads to runtime failures"}],"metadata":{"estimatedTime":"3 hours","difficulty":"intermediate","prerequisites":["Day 1","Day 45"],"topics":["Virtual Environments","Dependency Management","pip","Poetry","Docker"],"tags":["venv","pip","poetry","requirements","docker","dependencies","reproducibility"]}},"topicSlug":"python","navigation":{"previous":{"dayNumber":58,"title":"Week 8 Capstone: Production-Grade API Client","sprintNumber":3},"next":{"dayNumber":60,"title":"Requirements Files and Dependency Management","sprintNumber":3}},"dayNumber":59,"totalDays":66,"mathEnabled":false,"starterCode":"# WITHOUT virtual environments - DISASTER\n\n# Working on Project A (Django 3)\n$ pip install django==3.2.0\n# Works fine, Project A runs\n\n# Now work on Project B (Django 4)\n$ pip install django==4.2.0\n# This UPGRADES Django globally\n# Project A now BROKEN - import errors, API changes\n\n# Problem: Both projects share same Python installation\n# Installing packages for one project affects all projects\n# Team members have different versions\n# Production environment different from local\n# \"Works on my machine\" syndrome"}]}]}]]}]