# 🎯 Module Path Demo

import sys
import os

print("🗺️ Python Module Search Demo:")

# Show where Python looks for modules
print("📍 Module search locations:")
for i, path in enumerate(sys.path[:5], 1):  # Show first 5
    print(f"  {i}. {path}")

if len(sys.path) > 5:
    print(f"  ... and {len(sys.path) - 5} more locations")

# Current working directory
current_dir = os.getcwd()
print(f"\n📁 Current directory: {os.path.basename(current_dir)}")

# Check if current directory is in Python's search path
if current_dir in sys.path:
    print("✅ Current directory is in search path")
else:
    print("❌ Current directory is NOT in search path")

# Show Python's version and executable location
print(f"\n🐍 Python info:")
print(f"  Version: {sys.version.split()[0]}")
print(f"  Executable: {sys.executable}")
print(f"  Platform: {sys.platform}")

# Built-in modules (always available)
builtin_count = len(sys.builtin_module_names)
print(f"\n🛠️ Built-in modules available: {builtin_count}")
print(f"  Examples: {list(sys.builtin_module_names)[:5]}...")

# 📦 Package Structure Demo

import os
import sys

def show_package_structure():
    """Demonstrate how Python packages work"""
    
    print("📦 Python Package Structure:")
    
    # Example of a typical package structure
    package_example = """
    my_project/
    ├── main.py                 # Main application file
    ├── config.py              # Configuration settings
    ├── utils/                  # Utility package
    │   ├── __init__.py        # Makes it a package
    │   ├── helpers.py         # Helper functions
    │   └── validators.py      # Validation functions
    ├── data/                  # Data processing package
    │   ├── __init__.py
    │   ├── readers.py         # Data reading functions
    │   └── writers.py         # Data writing functions
    └── tests/                 # Testing package
        ├── __init__.py
        ├── test_utils.py
        └── test_data.py
    """
    
    print(package_example)
    
    print("🔧 How packages work:")
    import_examples = [
        ("import utils", "Import entire package"),
        ("from utils import helpers", "Import specific module"),
        ("from utils.helpers import clean_text", "Import specific function"),
        ("import data.readers as readers", "Import with alias"),
        ("from data import *", "Import all (not recommended)")
    ]
    
    for import_cmd, description in import_examples:
        print(f"  {import_cmd:<35} # {description}")
    
    print(f"\n📄 __init__.py file purposes:")
    purposes = [
        "Makes directory a Python package",
        "Controls what gets imported with 'from package import *'",
        "Provides package-level initialization",
        "Sets up convenient package interfaces",
        "Defines package constants and configuration"
    ]
    
    for purpose in purposes:
        print(f"  • {purpose}")

show_package_structure()

# 🛠️ Import Path Management Demo

import sys
import os

def demonstrate_path_management():
    """Show how to manage Python import paths"""
    
    print("🛠️ Import Path Management:")
    
    # Current sys.path length
    original_path_length = len(sys.path)
    print(f"Original sys.path has {original_path_length} directories")
    
    # Adding a custom path (temporarily)
    custom_path = "/path/to/my/modules"  # This would be a real path
    if custom_path not in sys.path:
        sys.path.append(custom_path)
        print(f"✅ Added custom path: {custom_path}")
    
    # Show different ways to add paths
    print(f"\n📝 Methods to add module paths:")
    
    methods = [
        ("sys.path.append(path)", "Add to end of search list"),
        ("sys.path.insert(0, path)", "Add to beginning (highest priority)"),
        ("PYTHONPATH environment variable", "System-wide path addition"),
        ("Virtual environment", "Isolated project environment"),
        (".pth files", "Permanent path additions in site-packages")
    ]
    
    for method, description in methods:
        print(f"  {method:<35} # {description}")
    
    # Path analysis
    print(f"\n🔍 Current path analysis:")
    
    # Count different types of paths
    stdlib_paths = 0
    site_packages = 0
    local_paths = 0
    
    for path in sys.path:
        if 'site-packages' in path:
            site_packages += 1
        elif 'lib/python' in path or 'Lib' in path:
            stdlib_paths += 1
        else:
            local_paths += 1
    
    print(f"  Standard library paths: {stdlib_paths}")
    print(f"  Site-packages paths: {site_packages}")
    print(f"  Local/other paths: {local_paths}")
    
    # Clean up - remove the custom path we added
    if custom_path in sys.path:
        sys.path.remove(custom_path)
        print(f"\n🧹 Cleaned up custom path")
    
    # Show where specific modules come from
    print(f"\n📍 Module locations:")
    
    import json
    import os
    import sys
    
    modules_to_check = [('json', json), ('os', os), ('sys', sys)]
    
    for name, module in modules_to_check:
        if hasattr(module, '__file__') and module.__file__:
            location = os.path.dirname(module.__file__)
            print(f"  {name}: {location}")
        else:
            print(f"  {name}: Built-in module (no file location)")

demonstrate_path_management()

# 🌐 Virtual Environment Demo

import sys
import os

def virtual_environment_info():
    """Show information about virtual environments"""
    
    print("🌐 Virtual Environment Information:")
    
    # Check if we're in a virtual environment
    in_venv = hasattr(sys, 'real_prefix') or (
        hasattr(sys, 'base_prefix') and sys.base_prefix != sys.prefix
    )
    
    print(f"Running in virtual environment: {'Yes' if in_venv else 'No'}")
    
    if in_venv:
        print(f"Virtual environment prefix: {sys.prefix}")
        if hasattr(sys, 'base_prefix'):
            print(f"Base Python prefix: {sys.base_prefix}")
    
    # Python executable location
    python_executable = sys.executable
    print(f"Python executable: {python_executable}")
    
    # Environment variables related to Python
    print(f"\n🔧 Python environment variables:")
    
    env_vars = [
        ('PYTHONPATH', 'Additional module search paths'),
        ('PYTHONHOME', 'Python installation directory'),
        ('VIRTUAL_ENV', 'Current virtual environment path'),
        ('PATH', 'System executable search paths')
    ]
    
    for var, description in env_vars:
        value = os.environ.get(var)
        if value:
            if var == 'PATH':
                # Show number of PATH entries instead of full PATH
                path_count = len(value.split(os.pathsep))
                print(f"  {var}: {path_count} directories")
            elif len(value) > 50:
                print(f"  {var}: {value[:50]}...")
            else:
                print(f"  {var}: {value}")
        else:
            print(f"  {var}: Not set")
    
    # Virtual environment benefits
    print(f"\n💡 Virtual environment benefits:")
    benefits = [
        "Isolate project dependencies",
        "Avoid conflicts between different project requirements",
        "Test with different Python versions",
        "Share exact environment with teammates",
        "Keep global Python installation clean"
    ]
    
    for benefit in benefits:
        print(f"  • {benefit}")
    
    # Common virtual environment commands
    print(f"\n📋 Common virtual environment commands:")
    commands = [
        ("python -m venv myenv", "Create virtual environment"),
        ("source myenv/bin/activate", "Activate (Linux/Mac)"),
        ("myenv\\Scripts\\activate", "Activate (Windows)"),
        ("pip install package", "Install package in virtual env"),
        ("pip freeze > requirements.txt", "Save current packages"),
        ("pip install -r requirements.txt", "Install from requirements"),
        ("deactivate", "Exit virtual environment")
    ]
    
    for command, description in commands:
        print(f"  {command:<35} # {description}")

virtual_environment_info()