మాడ్యూల్స్, ప్యాకేజీలు & వర్చువల్ ఎన్విరాన్‌మెంట్స్

1 మాడ్యూల్ అంటే ఏమిటి? (What is a Python Module?)

పైథాన్‌లో మాడ్యూల్ (Module) అనేది పైథాన్ కోడ్ (ఫంక్షన్లు, క్లాస్‌లు, వేరియబుల్స్) కలిగిన ఏదైనా ఒక సాధారణ .py ఫైల్!

ఉదాహరణకు, మీరు calculator.py అనే ఫైల్‌ను సృష్టిస్తే, అది తక్షణమే ఒక మాడ్యూల్ అవుతుంది. దానిలోని ఫంక్షన్లను వేరే ఫైల్ నుండి import calculator అని రాసి నిశ్చింతగా ఉపయోగించుకోవచ్చు.

• నేమ్‌స్పేస్ ఐసోలేషన్ (Namespace Isolation): ఒక మాడ్యూల్‌లోని వేరియబుల్స్ మరొక మాడ్యూల్‌లోని వేరియబుల్స్‌తో ఘర్షణ పడకుండా (Name Collisions రాకుండా) పైథాన్ ప్రతి మాడ్యూల్‌కు ప్రత్యేకమైన నేమ్‌స్పేస్‌ను కేటాయిస్తుంది.
• కోడ్ రీ-యూజబిలిటీ: ఒకసారి రాసిన లైబ్రరీ కోడ్‌ను వందలాది ప్రాజెక్టులలో ఇంపోర్ట్ చేసుకోవచ్చు.

2 CPython import సిస్టమ్ అంతర్గత పనితీరు

మీరు import math అని రాసినప్పుడు తెరవెనుక CPython క్రింది ఖచ్చితమైన 3-దశల ఆర్కిటెక్చర్‌ను అమలు చేస్తుంది:

3 Import సింటాక్స్ వైవిధ్యాలు (Variants & Best Practices)

పైథాన్‌లో మాడ్యూల్స్ ఇంపోర్ట్ చేయడానికి నాలుగు ప్రధాన పద్ధతులు ఉన్నాయి:

• 1. import module_name: అత్యంత సురక్షితమైనది. ఫంక్షన్లను పిలిచేటప్పుడు module_name.func() అని స్పష్టంగా మాడ్యూల్ పేరుతో పిలుస్తాము: import math; print(math.sqrt(16))
• 2. from module_name import func1, func2: నిర్దిష్టమైన ఫంక్షన్లను నేరుగా మన కరెంట్ నేమ్‌స్పేస్‌లోకి తెస్తుంది: from math import sqrt, pi; print(sqrt(25))
• 3. import module_name as alias: మాడ్యూల్ పేరు పెద్దదిగా ఉన్నప్పుడు నిక్-నేమ్ (అలియాస్) ఇవ్వడం (డేటా సైన్స్‌లో పరిశ్రమ ప్రమాణం): import numpy as np; import pandas as pd
• 4. from module_name import * (⚠️ డేంజరస్ యాంటీ-ప్యాటర్న్): ఆ మాడ్యూల్‌లోని అన్ని ఫంక్షన్లను ఒకేసారి గుడ్డిగా తెస్తుంది. దీనివల్ల మన వేరియబుల్స్ ఓవర్‌రైట్ అయిపోయి తీవ్రమైన బగ్‌లు వస్తాయి. ప్రొడక్షన్ కోడ్‌లో దీనిని ఎట్టి పరిస్థితుల్లోనూ వాడకూడదు!

4 కస్టమ్ మాడ్యూల్స్ సృష్టి & లోకల్ ఇంపోర్ట్స్

ఒక కస్టమ్ మాడ్యూల్ ఎలా తయారు చేయాలో చూద్దాం. మీ ప్రాజెక్ట్ ఫోల్డర్‌లో string_utils.py అనే ఫైల్‌ను సృష్టించి అందులో ఫంక్షన్స్ రాసి, ప్రధాన అప్లికేషన్‌లో ఎలా ఇంపోర్ట్ చేయాలో క్రింది కోడ్‌లో చూడండి:

# =====================================================================
# కస్టమ్ మాడ్యూల్ ఫంక్షన్ల డెమో: string_utils లాజిక్
# =====================================================================

def to_url_slug(title: str) -> str:
    """ఒక ఆర్టికల్ శీర్షికను SEO-ఫ్రెండ్లీ URL స్లగ్‌గా మారుస్తుంది."""
    clean = "".join([c.lower() if c.isalnum() or c == " " else "" for c in title])
    return "-".join(clean.split())

def mask_sensitive_aadhaar(aadhaar_num: str) -> str:
    """ఆధార్ నంబర్‌లోని మొదటి 8 అంకెలను మాస్క్ చేస్తుంది (xxxx-xxxx-1234)."""
    digits = aadhaar_num.replace("-", "").replace(" ", "")
    if len(digits) != 12:
        return "తప్పుడు ఆధార్ నంబర్!"
    return f"XXXX-XXXX-{digits[-4:]}"

# ప్రధాన స్క్రిప్ట్‌లో దీనిని వాడుకోవడం:
blog_title = "Python 3 టుటోరియల్స్ ఇన్ తెలుగు 2026!"
user_aadhaar = "1234-5678-9012"

print("SEO స్లగ్    :", to_url_slug(blog_title))
print("మాస్క్డ్ ఆధార్ :", mask_sensitive_aadhaar(user_aadhaar))

5 The Infamous if __name__ == '__main__': గార్డ్‌రైల్

పైథాన్ ప్రోగ్రామర్లు ప్రతి ఫైల్ చివర రాసే if __name__ == '__main__': వెనుక ఉన్న లోతైన రహస్యం ఏమిటో తెలుసా?

పైథాన్ ఒక ఫైల్‌ను రన్ చేస్తున్నప్పుడు, దానికి స్వయంచాలకంగా __name__ అనే ప్రత్యేకమైన వేరియబుల్‌ను కేటాయిస్తుంది:

• నేరుగా రన్ చేసినప్పుడు: మీరు టెర్మినల్ నుండి python my_script.py అని ఫైల్‌ను నేరుగా రన్ చేస్తే, పైథాన్ దాని __name__ విలువను '__main__' గా సెట్ చేస్తుంది.
• మరొక ఫైల్‌లోకి ఇంపోర్ట్ అయినప్పుడు: ఎవరైనా import my_script అని ఇంపోర్ట్ చేసుకుంటే, దాని __name__ విలువ ఆ ఫైల్ పేరు 'my_script' గా మారుతుంది!

6 ప్యాకేజీలు అంటే ఏమిటి? (Packages & __init__.py)

మాడ్యూల్ అనేది ఒక సింగిల్ ఫైల్ అయితే, ప్యాకేజీ (Package) అనేది అనేక మాడ్యూల్స్‌ను కలిగి ఉండే ఒక డైరెక్టరీ (ఫోల్డర్)!

ఒక ఫోల్డర్‌ను పైథాన్ అధికారిక ప్యాకేజీగా గుర్తించాలంటే అందులో సాంప్రదాయకంగా __init__.py అనే ప్రత్యేక ఫైల్ ఉండాలి.

పైథాన్ 3.3+ నుండి __init__.py లేకపోయినా Namespace Packages సపోర్ట్ ఉన్నప్పటికీ, ప్యాకేజీ ఎక్స్‌పోర్ట్‌లను (__all__) నియంత్రించడానికి మరియు ప్రారంభ లాజిక్ రన్ చేయడానికి __init__.py ఉంచడం నేటికీ బెస్ట్ ప్రాక్టీస్.

7 కోడ్ డెమో 1: మాడ్యూల్ ఇంట్రోస్పెక్షన్ & sys.modules

CPython లోడ్ చేసిన మాడ్యూల్స్ మరియు వాటి ఫైల్ పాత్‌లను ప్రోగ్రామాటిక్‌గా ఎలా పరిశీలించవచ్చో చూడండి:

# =====================================================================
# చాప్టర్ 19 డెమో 1: sys మాడ్యూల్ ఇంట్రోస్పెక్షన్ & sys.path సెర్చ్ ఆర్డర్
# =====================================================================
import sys
import math

print("=== 1. ప్రస్తుత స్క్రిప్ట్ __name__ వేరియబుల్ ===")
print(f"__name__ విలువ : {__name__} (నేరుగా రన్ అయినందున '__main__' గా ఉంది)")

print("\n=== 2. sys.modules లో math మాడ్యూల్ ఉనికి ===")
print(f"math క్యాష్ అయిందా? : {'math' in sys.modules}")
print(f"math మాడ్యూల్ రిఫరెన్స్: {sys.modules['math']}")

print("\n=== 3. CPython సెర్చ్ పాత్స్ (sys.path Top 3) ===")
for idx, p in enumerate(sys.path[:3], start=1):
    print(f"  {idx}. {p}")

8 pip — పైథాన్ అఫీషియల్ ప్యాకేజీ మేనేజర్ & PyPI

ప్రపంచవ్యాప్తంగా డెవలపర్లు తయారు చేసిన లక్షలాది ఓపెన్ సోర్స్ లైబ్రరీలు PyPI (Python Package Index - pypi.org) లో అందుబాటులో ఉంటాయి. వాటిని మన సిస్టమ్‌లో ఇన్‌స్టాల్ చేసుకోవడానికి ఉపయోగపడే టూలే pip (Pip Installs Packages).

9 వర్చువల్ ఎన్విరాన్‌మెంట్స్ (venv) ఎందుకు తప్పనిసరి?

మీ కంప్యూటర్‌లో రెండు వేర్వేరు ప్రాజెక్టులు ఉన్నాయనుకోండి:

• Project A (పాత వెబ్‌సైట్): Django వెర్షన్ 3.2 పై నడుస్తుంది.
• Project B (నూతన AI పోర్టల్): Django తాజా వెర్షన్ 5.0 కావాలి.

మీరు గ్లోబల్ పైథాన్‌లో Django 5.0 ఇన్‌స్టాల్ చేస్తే, పాత Project A క్రాష్ అవుతుంది! ఈ ఘర్షణలను నివారించడానికి ప్రతి ప్రాజెక్ట్‌కు ఒక ప్రత్యేకమైన, ఒంటరి (Isolated) వాతావరణాన్ని సృష్టించే సాధనమే వర్చువల్ ఎన్విరాన్‌మెంట్ (venv).

10 venv లైఫ్‌సైకిల్ కమాండ్స్ (Windows & Linux)

పైథాన్ స్టాండర్డ్ లైబ్రరీలోనే venv అంతర్నిర్మితంగా లభిస్తుంది:

11 ఆధునిక పైథాన్ టూలింగ్ (Poetry, UV, Pipenv)

ఆధునిక క్లౌడ్ నేటివ్ డెవలప్‌మెంట్‌లో సాధారణ pip కాకుండా వేగవంతమైన ప్యాకేజీ మేనేజర్లు ప్రాచుర్యం పొందాయి:

• UV (Astral): రస్ట్ (Rust) లో రాయబడిన అత్యంత వేగవంతమైన ప్యాకేజీ మేనేజర్. pip కంటే 10-100 రెట్లు వేగంగా లైబ్రరీలను ఇన్‌స్టాల్ చేస్తుంది.
• Poetry: డిపెండెన్సీ లాకింగ్ (poetry.lock) మరియు ప్రాజెక్ట్ ప్యాకేజింగ్ కోసం పరిశ్రమ ప్రామాణిక టూల్.

12 కామన్ బిగినర్స్ మిస్టేక్స్ & మాడ్యూల్ షాడోయింగ్ ట్రాప్

• The File Name Shadowing Trap (ప్రమాదకరమైన తప్పు!): మీ ప్రాక్టీస్ స్క్రిప్ట్‌కు math.py, random.py, లేదా email.py అని పేరు పెట్టి, లోపల import math అని రాస్తే — పైథాన్ స్టాండర్డ్ లైబ్రరీని కాకుండా మీ ఫైల్‌నే ఇంపోర్ట్ చేసుకుంటుంది! ఫలితంగా AttributeError: module 'math' has no attribute 'sqrt' వచ్చి ప్రోగ్రామ్ క్రాష్ అవుతుంది! మీ ఫైళ్లకు ఎప్పుడూ పైథాన్ లైబ్రరీ పేర్లను పెట్టకండి.
• Circular Imports బగ్: File A File B ని, File B File A ని ఇంపోర్ట్ చేసుకోవడం వల్ల వచ్చే డెడ్‌లాక్ ఎర్రర్. దీనిని నివారించడానికి షేర్డ్ లాజిక్‌ను ఒక మూడవ ఫైల్ common.py లోకి తరలించాలి.
• వర్చువల్ ఎన్విరాన్‌మెంట్ యాక్టివేట్ చేయకుండా ఇన్‌స్టాల్ చేయడం: గ్లోబల్ మెషీన్‌లో లైబ్రరీలను కుక్కేయడం వల్ల పర్మిషన్ ఎర్రర్లు మరియు డిపెండెన్సీ గందరగోళం ఏర్పడుతుంది.

13 రియల్-వరల్డ్ ప్రాజెక్ట్: "Package Dependency Security & Vulnerability Auditor"

ఈ పంతొమ్మిదవ అధ్యాయంలో నేర్చుకున్న అన్ని అంశాలను (మాడ్యూల్స్, ప్యాకేజీలు, __name__ గార్డ్‌రైల్, sys.path, requirements.txt పార్సింగ్) సమగ్రంగా అనుసంధానిస్తూ — సాఫ్ట్‌వేర్ డిపెండెన్సీలలో కాలం చెల్లిన లేదా ప్రమాదకరమైన లైబ్రరీలను గుర్తించే పూర్తి స్థాయి Enterprise Package Security Auditor Engine ను నిర్మిద్దాం!

# =====================================================================
# చాప్టర్ 19 మినీ ప్రాజెక్ట్: Package Security & Dependency Audit Engine
# కాన్సెప్ట్స్: Custom Modules Architecture, __name__ == '__main__' Guard,
#             requirements.txt Parsing, Vulnerability Advisory Matching
# =====================================================================

# తెలిసిన సెక్యూరిటీ వల్నరబిలిటీస్ గ్లోబల్ డేటాబేస్ (CVE Advisory Mock)
KNOWN_VULNERABLE_PACKAGES = {
    "requests": {"vulnerable_below": "2.31.0", "cve": "CVE-2023-32681", "risk": "CRITICAL"},
    "flask": {"vulnerable_below": "2.2.5", "cve": "CVE-2023-30861", "risk": "HIGH"},
    "urllib3": {"vulnerable_below": "1.26.17", "cve": "CVE-2023-43804", "risk": "MEDIUM"},
    "django": {"vulnerable_below": "4.2.4", "cve": "CVE-2023-36053", "risk": "CRITICAL"}
}

def parse_requirements_manifest(manifest_content: str) -> list[tuple[str, str]]:
    """requirements.txt టెక్స్ట్ ఫైల్‌ను పార్స్ చేసి (ప్యాకేజీ, వెర్షన్) టుపుల్స్‌గా అందిస్తుంది."""
    parsed_packages = []
    lines = manifest_content.strip().split("\n")

    for line in lines:
        line = line.strip()
        if not line or line.startswith("#"):
            continue
        if "==" in line:
            pkg, ver = line.split("==")
            parsed_packages.append((pkg.strip().lower(), ver.strip()))
        elif ">=" in line:
            pkg, ver = line.split(">=")
            parsed_packages.append((pkg.strip().lower(), ver.strip()))

    return parsed_packages

def audit_project_dependencies(dependencies: list[tuple[str, str]]) -> dict:
    """డిపెండెన్సీలను సెక్యూరిటీ డేటాబేస్‌తో పోల్చి సమగ్ర నివేదికను ఇస్తుంది."""
    findings = []
    clean_count = 0

    for pkg_name, installed_ver in dependencies:
        if pkg_name in KNOWN_VULNERABLE_PACKAGES:
            advisory = KNOWN_VULNERABLE_PACKAGES[pkg_name]
            # సాధారణ వెర్షన్ కంపారిజన్
            if installed_ver < advisory["vulnerable_below"]:
                findings.append({
                    "package": pkg_name,
                    "installed": installed_ver,
                    "safe_version": advisory["vulnerable_below"],
                    "cve": advisory["cve"],
                    "risk": advisory["risk"]
                })
            else:
                clean_count += 1
        else:
            clean_count += 1

    return {
        "total_audited": len(dependencies),
        "clean_packages": clean_count,
        "vulnerable_packages": findings
    }

def print_security_audit_report(report: dict):
    """అందమైన సెక్యూరిటీ ఆడిట్ రిపోర్ట్ కన్సోల్ ప్రింటింగ్."""
    print("\n" + "=" * 74)
    print(f"{'🛡️ మన సాఫ్ట్‌వేర్ — పైథాన్ ప్యాకేజీ సెక్యూరిటీ ఆడిట్ రిపోర్ట్ 2026':^74}")
    print("=" * 74)
    print(f"మొత్తం ఆడిట్ చేసిన లైబ్రరీలు : {report['total_audited']}")
    print(f"సురక్షితమైన ప్యాకేజీలు       : {report['clean_packages']}")
    print(f"గుర్తించిన సెక్యూరిటీ లోపాలు : {len(report['vulnerable_packages'])}")
    print("-" * 74)

    if not report["vulnerable_packages"]:
        print("  🎉 అభినందనలు! ఎటువంటి సెక్యూరిటీ లోపాలు కనుగొనబడలేదు. అన్నీ సురక్షితం!")
    else:
        print(f"{'ప్యాకేజీ':<14} {'ఇన్‌స్టాల్ వెర్షన్':<18} {'సేఫ్ వెర్షన్':<16} {'CVE ఐడీ':<16} {'తీవ్రత':^10}")
        print("-" * 74)
        for issue in report["vulnerable_packages"]:
            risk_badge = "🔴 CRITICAL" if issue["risk"] == "CRITICAL" else "🟡 " + issue["risk"]
            print(f"{issue['package']:<14} {issue['installed']:<18} {issue['safe_version']:<16} {issue['cve']:<16} {risk_badge}")

    print("=" * 74)
    print(f"{'👉 తక్షణ చర్య: pip install --upgrade [package] ద్వారా సురక్షిత వెర్షన్‌కు మారండి!':^74}")
    print("=" * 74 + "\n")

# ఆడిట్ డెమో ఎగ్జిక్యూషన్
sample_requirements_file = """
# ప్రొడక్షన్ మైక్రోసర్వీస్ డిపెండెన్సీలు
fastapi==0.110.0
requests==2.28.1
urllib3==1.26.15
pydantic==2.6.4
flask==2.1.2
uvicorn==0.28.0
"""

if __name__ == "__main__":
    dependencies_list = parse_requirements_manifest(sample_requirements_file)
    audit_results = audit_project_dependencies(dependencies_list)
    print_security_audit_report(audit_results)

★ ఈ అధ్యాయంపై ప్రాక్టీస్ క్విజ్ (Knowledge Check)