Upload folder using huggingface_hub

.gitattributes

@@ -33,3 +33,7 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+venv/Lib/site-packages/__pycache__/typing_extensions.cpython-314.pyc filter=lfs diff=lfs merge=lfs -text
+venv/Lib/site-packages/anyio/_backends/__pycache__/_asyncio.cpython-314.pyc filter=lfs diff=lfs merge=lfs -text
+venv/Lib/site-packages/anyio/_backends/__pycache__/_trio.cpython-314.pyc filter=lfs diff=lfs merge=lfs -text
+venv/Lib/site-packages/click/__pycache__/core.cpython-314.pyc filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,6 @@
+venv/
+__pycache__/
+.pytest_cache/
+.ipynb_checkpoints/
+uploads/*
+test_backend.py

Dockerfile

@@ -0,0 +1,13 @@
+FROM python:3.11-slim
+
+WORKDIR /code
+
+COPY requirements.txt .
+
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+EXPOSE 7860
+
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

app.py

@@ -0,0 +1,261 @@
+import os
+import time
+import shutil
+import logging
+import pandas as pd
+import numpy as np
+from contextlib import asynccontextmanager
+from fastapi import FastAPI, UploadFile, File, HTTPException, Request
+from fastapi.middleware.cors import CORSMiddleware
+
+# Import our utility functions
+from utils import (
+    load_pickle_file,
+    preprocess_nids_data,
+    preprocess_malware_data,
+    get_nids_threat_details,
+    get_malware_threat_details,
+)
+
+# Set up logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger("backend_app")
+
+# Ensure uploads directory exists
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+UPLOADS_DIR = os.path.join(BASE_DIR, "uploads")
+os.makedirs(UPLOADS_DIR, exist_ok=True)
+
+# Risk levels mapping for prioritization
+RISK_PRIORITY = {
+    "Critical": 4,
+    "High": 3,
+    "Medium": 2,
+    "Low": 1
+}
+
+# Lifespan context manager for loading models once at startup
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    logger.info("Starting FastAPI server: Loading ML models, scalers, and encoders...")
+    try:
+        # Load NIDS models
+        app.state.nids_model = load_pickle_file("nids_model.pkl")
+        app.state.nids_scaler = load_pickle_file("nids_scaler.pkl")
+        app.state.nids_label_encoder = load_pickle_file("nids_label_encoder.pkl")
+        
+        # Load Malware models
+        app.state.malware_model = load_pickle_file("malware_model.pkl")
+        app.state.malware_scaler = load_pickle_file("malware_scaler.pkl")
+        app.state.malware_label_encoder = load_pickle_file("malware_label_encoder.pkl")
+        
+        logger.info("All pre-trained ML models and scalers loaded successfully.")
+    except Exception as e:
+        logger.error(f"Critical error loading models during startup: {str(e)}")
+        # We do not crash the app startup, but subsequent requests will fail gracefully
+        # or we let it raise so the service fails to start if models are missing
+        raise RuntimeError(f"Server startup failed due to missing/invalid models: {str(e)}")
+        
+    yield
+    logger.info("Shutting down FastAPI server: Clean up resources if necessary.")
+
+
+app = FastAPI(
+    title="AI-Based Cyber Threat Detection Framework API",
+    description="Production-ready FastAPI backend for running NIDS and Malware predictions.",
+    version="1.0.0",
+    lifespan=lifespan
+)
+
+# Configure CORS Middleware
+# Allows requests from any origin (e.g. frontend dev servers, Hugging Face Spaces, etc.)
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+@app.get("/")
+async def root():
+    return {
+        "status": "online",
+        "message": "AI-Based Cyber Threat Detection Backend is running.",
+        "docs_url": "/docs"
+    }
+
+
+@app.post("/predict/network")
+async def predict_network(request: Request, file: UploadFile = File(...)):
+    """
+    Accepts a network traffic features CSV file, runs NIDS model prediction, and returns
+    predictions, confidence, risk levels, and security recommendations.
+    """
+    # 1. Validate file extension
+    if not file.filename.endswith(".csv"):
+        raise HTTPException(status_code=400, detail="Invalid file format. Only CSV files are supported.")
+    
+    # 2. Save CSV to uploads folder for tracking/logging
+    file_path = os.path.join(UPLOADS_DIR, f"nids_{int(time.time())}_{file.filename}")
+    try:
+        with open(file_path, "wb") as buffer:
+            shutil.copyfileobj(file.file, buffer)
+    except Exception as e:
+        logger.error(f"Failed to save file: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Failed to process file upload: {str(e)}")
+
+    # 3. Read CSV into Pandas DataFrame
+    try:
+        df = pd.read_csv(file_path)
+    except Exception as e:
+        logger.error(f"Failed to read CSV: {str(e)}")
+        raise HTTPException(status_code=400, detail=f"Failed to parse CSV file: {str(e)}")
+
+    # 4. Check if DataFrame is empty
+    if df.empty:
+        raise HTTPException(status_code=400, detail="The uploaded CSV file contains no data.")
+
+    # 5. Preprocess and Run Inference
+    try:
+        # Retrieve models from app state
+        scaler = request.app.state.nids_scaler
+        model = request.app.state.nids_model
+        label_encoder = request.app.state.nids_label_encoder
+
+        # Run preprocessing (imputing, feature selection, scaling)
+        X_scaled = preprocess_nids_data(df, scaler)
+
+        # Run prediction
+        predictions = model.predict(X_scaled)
+        
+        # Decode target labels
+        decoded_labels = label_encoder.inverse_transform(predictions)
+
+        # Get confidence/probabilities
+        if hasattr(model, "predict_proba"):
+            probs = model.predict_proba(X_scaled)
+            confidences = np.max(probs, axis=1).tolist()
+        else:
+            # Fallback if model does not support predict_proba
+            confidences = [1.0] * len(predictions)
+
+        # Generate list of individual predictions
+        results = []
+        for idx, (label, conf) in enumerate(zip(decoded_labels, confidences)):
+            details = get_nids_threat_details(label, conf)
+            results.append({
+                "row_index": idx,
+                "prediction": str(label),
+                "confidence": round(float(conf), 4),
+                "risk_level": details["risk_level"],
+                "recommendation": details["recommendation"]
+            })
+
+        # Determine overall threat summary (highest threat in the batch)
+        highest_threat_result = max(results, key=lambda x: RISK_PRIORITY.get(x["risk_level"], 0))
+
+        return {
+            "prediction": highest_threat_result["prediction"],
+            "confidence": highest_threat_result["confidence"],
+            "risk_level": highest_threat_result["risk_level"],
+            "recommendation": highest_threat_result["recommendation"],
+            "is_batch": len(results) > 1,
+            "total_samples": len(results),
+            "results": results
+        }
+
+    except ValueError as val_err:
+        logger.warning(f"Validation error in NIDS processing: {str(val_err)}")
+        raise HTTPException(status_code=400, detail=str(val_err))
+    except Exception as e:
+        logger.error(f"Prediction logic error: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"An error occurred during prediction processing: {str(e)}")
+
+
+@app.post("/predict/malware")
+async def predict_malware(request: Request, file: UploadFile = File(...)):
+    """
+    Accepts a malware classification features CSV file, runs malware prediction model, and returns
+    predictions, confidence, risk levels, and security recommendations.
+    """
+    # 1. Validate file extension
+    if not file.filename.endswith(".csv"):
+        raise HTTPException(status_code=400, detail="Invalid file format. Only CSV files are supported.")
+    
+    # 2. Save CSV to uploads folder for tracking/logging
+    file_path = os.path.join(UPLOADS_DIR, f"malware_{int(time.time())}_{file.filename}")
+    try:
+        with open(file_path, "wb") as buffer:
+            shutil.copyfileobj(file.file, buffer)
+    except Exception as e:
+        logger.error(f"Failed to save file: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Failed to process file upload: {str(e)}")
+
+    # 3. Read CSV into Pandas DataFrame
+    try:
+        df = pd.read_csv(file_path)
+    except Exception as e:
+        logger.error(f"Failed to read CSV: {str(e)}")
+        raise HTTPException(status_code=400, detail=f"Failed to parse CSV file: {str(e)}")
+
+    # 4. Check if DataFrame is empty
+    if df.empty:
+        raise HTTPException(status_code=400, detail="The uploaded CSV file contains no data.")
+
+    # 5. Preprocess and Run Inference
+    try:
+        # Retrieve models from app state
+        scaler = request.app.state.malware_scaler
+        model = request.app.state.malware_model
+        label_encoder = request.app.state.malware_label_encoder
+
+        # Run preprocessing (imputing, feature selection, scaling)
+        X_scaled = preprocess_malware_data(df, scaler)
+
+        # Run prediction
+        predictions = model.predict(X_scaled)
+        
+        # Decode target labels
+        decoded_labels = label_encoder.inverse_transform(predictions)
+
+        # Get confidence/probabilities
+        if hasattr(model, "predict_proba"):
+            probs = model.predict_proba(X_scaled)
+            confidences = np.max(probs, axis=1).tolist()
+        else:
+            # Fallback if model does not support predict_proba
+            confidences = [1.0] * len(predictions)
+
+        # Generate list of individual predictions
+        results = []
+        for idx, (label, conf) in enumerate(zip(decoded_labels, confidences)):
+            details = get_malware_threat_details(label, conf)
+            results.append({
+                "row_index": idx,
+                "prediction": str(label),
+                "confidence": round(float(conf), 4),
+                "risk_level": details["risk_level"],
+                "recommendation": details["recommendation"]
+            })
+
+        # Determine overall threat summary (highest threat in the batch)
+        highest_threat_result = max(results, key=lambda x: RISK_PRIORITY.get(x["risk_level"], 0))
+
+        return {
+            "prediction": highest_threat_result["prediction"],
+            "confidence": highest_threat_result["confidence"],
+            "risk_level": highest_threat_result["risk_level"],
+            "recommendation": highest_threat_result["recommendation"],
+            "is_batch": len(results) > 1,
+            "total_samples": len(results),
+            "results": results
+        }
+
+    except ValueError as val_err:
+        logger.warning(f"Validation error in malware processing: {str(val_err)}")
+        raise HTTPException(status_code=400, detail=str(val_err))
+    except Exception as e:
+        logger.error(f"Prediction logic error: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"An error occurred during prediction processing: {str(e)}")

generate_sample_csv.py

@@ -0,0 +1,73 @@
+import os
+import joblib
+import pandas as pd
+import numpy as np
+
+# Define paths
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+MODELS_DIR = os.path.join(BASE_DIR, "models")
+SCALER_PATH = os.path.join(MODELS_DIR, "nids_scaler.pkl")
+OUTPUT_PATH = os.path.join(BASE_DIR, "sample_nids.csv")
+
+print("=== Generating Sample NIDS CSV ===")
+
+# 1. Load the NIDS scaler
+if not os.path.exists(SCALER_PATH):
+    raise FileNotFoundError(f"Scaler not found at {SCALER_PATH}. Please make sure files are in the models folder.")
+
+try:
+    scaler = joblib.load(SCALER_PATH)
+    print("Successfully loaded nids_scaler.pkl")
+except Exception as e:
+    raise RuntimeError(f"Error loading scaler: {str(e)}")
+
+# 2. Get expected feature names
+if not hasattr(scaler, "feature_names_in_"):
+    raise ValueError("The loaded scaler does not contain feature_names_in_. Cannot determine column names automatically.")
+
+features = list(scaler.feature_names_in_)
+print(f"Scaler expects {len(features)} features.")
+
+# 3. Create realistic random values for NIDS dataset (based on KDD/NSL-KDD schema)
+np.random.seed(42)  # For reproducibility
+num_rows = 10
+data = {}
+
+# Define typical categoricals and binary flags
+categorical_choices = {
+    "protocol_type": ["tcp", "udp", "icmp"],
+    "service": ["http", "private", "smtp", "ftp_data", "domain_u", "other"],
+    "flag": ["SF", "S0", "REJ", "RSTR", "RSTO", "SH"]
+}
+
+binary_columns = ["land", "logged_in", "root_shell", "is_host_login", "is_guest_login"]
+
+for col in features:
+    if col in categorical_choices:
+        data[col] = np.random.choice(categorical_choices[col], size=num_rows)
+    elif col in binary_columns:
+        data[col] = np.random.choice([0, 1], size=num_rows, p=[0.9, 0.1])
+    elif "rate" in col:
+        # Rates are values between 0.0 and 1.0
+        data[col] = np.round(np.random.uniform(0.0, 1.0, size=num_rows), 4)
+    elif "count" in col:
+        # Counts are integers, e.g., 0 to 511
+        data[col] = np.random.randint(0, 512, size=num_rows)
+    elif col in ["src_bytes", "dst_bytes"]:
+        # Bytes can be larger integers
+        data[col] = np.random.randint(0, 100000, size=num_rows)
+    elif col == "duration":
+        # Connection duration
+        data[col] = np.random.randint(0, 1000, size=num_rows)
+    else:
+        # Default fallback for other numeric columns
+        data[col] = np.round(np.random.uniform(0.0, 10.0, size=num_rows), 4)
+
+# 4. Generate DataFrame and save to CSV
+df = pd.DataFrame(data)
+df.to_csv(OUTPUT_PATH, index=False)
+
+print(f"\nSuccessfully generated sample CSV file: {OUTPUT_PATH}")
+print(f"File contains {num_rows} rows and {len(df.columns)} columns.")
+print("\nGenerated Column Names:")
+print(list(df.columns))

models/malware_label_encoder.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7975ff23bb39595dea6c8269fde6c097def053484f61d47b4c498e54b579c9e0
+size 493

models/malware_model.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d41d1b8b501d10b9adb395522279cecbd4114be18fc770684a9d79ffe9251718
+size 107400

models/malware_scaler.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:da35101329afd2aaccc78f6edd12831d1b85d20ee8f6afb717e0ad2ef32e71bc
+size 1959

models/model_comparison.csv

@@ -0,0 +1,5 @@
+Model,Dataset,Accuracy,Weighted F1
+MLP,NSL-KDD Network Intrusion,0.9906573239906573,0.9904813707063973
+Random Forest,NSL-KDD Network Intrusion,0.996996996996997,0.9969694960841293
+MLP,Malware Classification,0.975,0.975
+Random Forest,Malware Classification,0.96125,0.9612461850640471

models/nids_label_encoder.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cc8d1d24b7fefd85676a8ec7478e9eb2cc0dc15bc841e233a59cc9311c0ab7ea
+size 590

models/nids_model.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3ba786d0f1eea01e2997af0e00894969df41058f8087e6f97bdccf2e8668e545
+size 132877

models/nids_scaler.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a0a0f944df560d2d4a1b1f1ca0c5fc041d0e9e4a0aab62562649001fcccfa384
+size 2527

requirements.txt

@@ -0,0 +1,7 @@
+fastapi>=0.110.0
+uvicorn>=0.28.0
+pandas>=2.0.0
+numpy>=1.24.0
+scikit-learn>=1.2.0
+python-multipart>=0.0.9
+joblib>=1.3.0

sample_nids.csv

@@ -0,0 +1,11 @@
+duration,protocol_type,service,flag,src_bytes,dst_bytes,land,wrong_fragment,urgent,hot,num_failed_logins,logged_in,num_compromised,root_shell,su_attempted,num_root,num_file_creations,num_shells,num_access_files,num_outbound_cmds,is_host_login,is_guest_login,count,srv_count,serror_rate,srv_serror_rate,rerror_rate,srv_rerror_rate,same_srv_rate,diff_srv_rate,srv_diff_host_rate,dst_host_count,dst_host_srv_count,dst_host_same_srv_rate,dst_host_diff_srv_rate,dst_host_same_src_port_rate,dst_host_srv_diff_host_rate,dst_host_serror_rate,dst_host_srv_serror_rate,dst_host_rerror_rate,dst_host_srv_rerror_rate
+102,icmp,other,SF,67435,87313,0,7.7513,2.7135,1.9872,6.233,0,6.3641,0,8.9609,2.2211,2.5178,2.3956,6.3231,0.1659,0,0,74,509,0.6919,0.5683,0.5026,0.9539,0.3851,0.9901,0.8101,470,152,0.0373,0.5314,0.0785,0.7146,0.7578,0.4735,0.8565,0.6433
+435,icmp,private,SF,56886,10627,0,9.395,8.2874,0.0552,3.309,0,3.1436,1,3.18,1.1987,4.9725,1.4489,6.3353,5.1209,1,1,112,472,0.652,0.0937,0.5769,0.9149,0.8511,0.1401,0.8671,142,185,0.8226,0.5406,0.0254,0.6602,0.0144,0.1732,0.6587,0.4583
+860,icmp,ftp_data,REJ,66803,8792,1,8.9483,3.5675,8.1546,0.6356,0,5.0857,0,1.1005,3.3762,3.0088,4.8945,5.3577,2.265,0,0,455,98,0.2243,0.3677,0.4925,0.3702,0.3169,0.5183,0.9132,91,62,0.3602,0.6374,0.9626,0.2799,0.1161,0.4339,0.1629,0.5456
+270,icmp,domain_u,REJ,31551,73969,0,5.979,2.8093,7.0686,3.1098,0,9.0757,0,2.2794,9.4291,2.8484,9.8565,0.9029,6.4517,0,0,419,152,0.7122,0.2652,0.1952,0.0155,0.1695,0.8774,0.5113,353,189,0.1271,0.7261,0.836,0.9549,0.046,0.3985,0.0706,0.9415
+106,tcp,http,S0,11394,43001,0,9.2187,5.427,7.2901,3.2518,0,2.4929,0,4.2711,3.232,0.3689,2.4206,8.353,1.7437,0,0,421,348,0.2372,0.244,0.7225,0.9283,0.5568,0.7408,0.5015,321,124,0.5222,0.9759,0.696,0.7379,0.0407,0.6159,0.6424,0.3861
+71,icmp,ftp_data,RSTR,69092,76552,0,0.8849,1.4092,7.7127,7.2961,0,4.1038,0,8.1801,5.1879,6.0956,6.7214,3.2078,6.9094,0,0,103,401,0.3254,0.973,0.2808,0.4282,0.9362,0.697,0.7983,287,149,0.77,0.5163,0.409,0.5544,0.8555,0.6351,0.0265,0.9612
+700,udp,private,RSTR,3890,23897,0,1.9598,8.022,0.7404,6.3756,0,7.5555,0,8.6073,7.0302,5.0268,7.6162,1.8652,3.8674,0,0,339,383,0.7465,0.3931,0.0243,0.9667,0.696,0.7025,0.65,214,313,0.2158,0.323,0.1733,0.6117,0.7037,0.0453,0.5858,0.9054
+20,tcp,other,SH,41606,68148,0,0.4523,0.7455,3.5847,8.8721,0,2.288,0,0.0695,3.6363,0.5148,2.3764,0.4078,9.3673,0,0,253,365,0.6496,0.892,0.6455,0.9636,0.5701,0.3595,0.702,446,57,0.6229,0.7952,0.1564,0.4196,0.4742,0.3746,0.9402,0.1958
+614,udp,domain_u,SH,96276,23483,0,3.2533,9.8689,1.1587,4.7221,0,0.7698,0,5.1075,9.7178,2.7865,7.2822,5.9089,1.3752,0,0,226,337,0.8492,0.6311,0.1771,0.853,0.0972,0.2936,0.7958,341,341,0.0853,0.2708,0.2502,0.2477,0.0978,0.6259,0.5755,0.0694
+121,udp,ftp_data,SH,80038,48555,1,3.8868,7.7224,8.631,1.1959,0,2.8975,0,4.1741,9.6245,9.0827,3.6778,6.7756,3.4107,0,0,111,193,0.6576,0.7948,0.9405,0.2944,0.615,0.8094,0.89,50,304,0.0517,0.439,0.5492,0.356,0.4916,0.5031,0.3882,0.1008

utils.py

@@ -0,0 +1,262 @@
+import os
+import joblib
+import pandas as pd
+import numpy as np
+import logging
+
+# Set up logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger("backend_utils")
+
+# Base paths
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+MODELS_DIR = os.path.join(BASE_DIR, "models")
+
+def load_pickle_file(filename: str):
+    """
+    Helper function to load a pickle file from the models directory.
+    """
+    filepath = os.path.join(MODELS_DIR, filename)
+    if not os.path.exists(filepath):
+        logger.error(f"Required model file not found: {filepath}")
+        raise FileNotFoundError(f"Model file not found: {filename} in models/ directory.")
+    try:
+        data = joblib.load(filepath)
+        logger.info(f"Successfully loaded {filename}")
+        return data
+    except Exception as e:
+        logger.error(f"Failed to load {filename}: {str(e)}")
+        raise RuntimeError(f"Error loading {filename}: {str(e)}")
+
+# ==========================================
+# CATEGORICAL MAPPINGS FOR NIDS
+# ==========================================
+
+# Standard mappings for NSL-KDD / KDD-99 categorical columns (alphabetical order matches scikit-learn's default LabelEncoder)
+PROTOCOL_MAP = {"icmp": 0, "tcp": 1, "udp": 2}
+
+FLAG_MAP = {
+    "OTH": 0, "REJ": 1, "RSTO": 2, "RSTOS0": 3, "RSTR": 4,
+    "S0": 5, "S1": 6, "S2": 7, "S3": 8, "SF": 9, "SH": 10
+}
+
+# Standard alphabetical list of services in NSL-KDD
+SERVICES_LIST = [
+    "IRC", "X11", "Z39_50", "aol", "auth", "bgp", "courier", "csnet_ns", "ctf", "daytime",
+    "discard", "domain", "domain_u", "echo", "eco_i", "ecr_i", "efs", "exec", "finger", "ftp",
+    "ftp_data", "gopher", "harvest", "hostnames", "http", "http_2784", "http_443", "http_8001",
+    "imap4", "iso_tsap", "jmp", "lpr", "mail", "map", "netbios_dgm", "netbios_ns", "netbios_ssn",
+    "netstat", "nnsp", "nntp", "ntp_u", "other", "pm_dump", "pop_2", "pop_3", "printer",
+    "private", "red_i", "remote_job", "rje", "shell", "smtp", "sql_net", "ssh", "sunrpc",
+    "supdup", "systat", "telnet", "tftp_u", "tim_i", "time", "urh_i", "urp_i", "uucp",
+    "uucp_path", "vmnet", "whois"
+]
+SERVICE_MAP = {service.lower(): idx for idx, service in enumerate(SERVICES_LIST)}
+
+def map_protocol(val):
+    if pd.isna(val):
+        return 1  # Default to tcp
+    v_str = str(val).strip().lower()
+    return PROTOCOL_MAP.get(v_str, 1)
+
+def map_flag(val):
+    if pd.isna(val):
+        return 9  # Default to SF
+    v_str = str(val).strip().upper()
+    return FLAG_MAP.get(v_str, 9)
+
+def map_service(val):
+    if pd.isna(val):
+        return SERVICE_MAP.get("other", 41)
+    v_str = str(val).strip().lower()
+    return SERVICE_MAP.get(v_str, SERVICE_MAP.get("other", 41))
+
+# ==========================================
+# PREPROCESSING FUNCTIONS
+# ==========================================
+
+def preprocess_nids_data(df: pd.DataFrame, scaler):
+    """
+    Preprocess Network Intrusion Detection (NIDS) data before inference.
+    
+    --------------------------------------------------------------------------
+    COPY-PASTE INSTRUCTION FROM YOUR GOOGLE COLAB NOTEBOOK:
+    If you had specific preprocessing steps in your Colab notebook (such as
+    dropping certain columns like ID or timestamps, replacing missing values, 
+    or encoding categorical variables), you should paste them here.
+    --------------------------------------------------------------------------
+    """
+    # Create copy to avoid SettingWithCopyWarning
+    df = df.copy()
+
+    # 1. Decode/map categorical text features to numeric codes if they are strings
+    if "protocol_type" in df.columns:
+        if pd.api.types.is_string_dtype(df["protocol_type"]):
+            df["protocol_type"] = df["protocol_type"].apply(map_protocol)
+            
+    if "service" in df.columns:
+        if pd.api.types.is_string_dtype(df["service"]):
+            df["service"] = df["service"].apply(map_service)
+            
+    if "flag" in df.columns:
+        if pd.api.types.is_string_dtype(df["flag"]):
+            df["flag"] = df["flag"].apply(map_flag)
+
+    # 2. Standard handling of missing values
+    df = df.fillna(0)
+
+    # 2. Align columns with the Scaler's expected inputs
+    # This automatically matches the column ordering and column list expected by the scaler.
+    if hasattr(scaler, "feature_names_in_"):
+        expected_cols = list(scaler.feature_names_in_)
+        missing_cols = [col for col in expected_cols if col not in df.columns]
+        if missing_cols:
+            raise ValueError(f"Missing required columns in uploaded NIDS CSV: {missing_cols}")
+        df_prepared = df[expected_cols]
+    else:
+        # Fallback if the scaler has no feature names (e.g. fit on raw numpy array)
+        # Select numeric columns only
+        df_prepared = df.select_dtypes(include=[np.number])
+        if hasattr(scaler, "n_features_in_"):
+            expected_dim = scaler.n_features_in_
+            if df_prepared.shape[1] != expected_dim:
+                raise ValueError(
+                    f"Number of numeric columns ({df_prepared.shape[1]}) "
+                    f"does not match model expected features ({expected_dim}). "
+                    "Please ensure columns are in the correct order and format."
+                )
+
+    # 3. Apply the saved scaler
+    X_scaled = scaler.transform(df_prepared)
+    return X_scaled
+
+
+def preprocess_malware_data(df: pd.DataFrame, scaler):
+    """
+    Preprocess Malware detection data before inference.
+    
+    --------------------------------------------------------------------------
+    COPY-PASTE INSTRUCTION FROM YOUR GOOGLE COLAB NOTEBOOK:
+    If you had specific preprocessing steps in your Colab notebook (such as
+    dropping columns like file hashes/names, target labels, filling nulls, 
+    or scaling specific features), you should paste them here.
+    --------------------------------------------------------------------------
+    """
+    # 1. Standard handling of missing values
+    df = df.fillna(0)
+
+    # 2. Align columns with the Scaler's expected inputs
+    if hasattr(scaler, "feature_names_in_"):
+        expected_cols = list(scaler.feature_names_in_)
+        missing_cols = [col for col in expected_cols if col not in df.columns]
+        if missing_cols:
+            raise ValueError(f"Missing required columns in uploaded Malware CSV: {missing_cols}")
+        df_prepared = df[expected_cols]
+    else:
+        # Fallback to numeric columns
+        df_prepared = df.select_dtypes(include=[np.number])
+        if hasattr(scaler, "n_features_in_"):
+            expected_dim = scaler.n_features_in_
+            if df_prepared.shape[1] != expected_dim:
+                raise ValueError(
+                    f"Number of numeric columns ({df_prepared.shape[1]}) "
+                    f"does not match model expected features ({expected_dim}). "
+                    "Please ensure columns are in the correct order and format."
+                )
+
+    # 3. Apply the saved scaler
+    X_scaled = scaler.transform(df_prepared)
+    return X_scaled
+
+# ==========================================
+# POST-PREDICTION MAPPER FUNCTIONS
+# ==========================================
+
+def get_nids_threat_details(prediction: str, confidence: float):
+    """
+    Maps a prediction string and confidence score to a Risk Level and Recommendation.
+    """
+    pred_lower = str(prediction).lower()
+    
+    if "normal" in pred_lower or "benign" in pred_lower:
+        return {
+            "risk_level": "Low",
+            "recommendation": "No threat detected. Continue standard network monitoring and log collection."
+        }
+    elif "dos" in pred_lower or "ddos" in pred_lower:
+        return {
+            "risk_level": "High",
+            "recommendation": "Potential Denial of Service (DoS/DDoS) attack detected. Enable rate-limiting, activate mitigation rules on your web application firewall, and check resource utilization."
+        }
+    elif "probe" in pred_lower or "scan" in pred_lower or "portscan" in pred_lower:
+        return {
+            "risk_level": "Medium",
+            "recommendation": "Network scanning or reconnaissance detected. Block scanning IP address(es) and ensure unnecessary ports are closed/secured."
+        }
+    elif "brute" in pred_lower or "exploit" in pred_lower or "botnet" in pred_lower or "infiltration" in pred_lower:
+        return {
+            "risk_level": "Critical",
+            "recommendation": "Active intrusion attempt or compromised host detected. Immediately isolate the infected network node, reset passwords, and run network security scans."
+        }
+    else:
+        # General default mapping based on confidence
+        if confidence > 0.8:
+            return {
+                "risk_level": "High",
+                "recommendation": "Highly suspicious network activity detected. Restrict communication with the source IP and verify system health."
+            }
+        elif confidence > 0.5:
+            return {
+                "risk_level": "Medium",
+                "recommendation": "Anomalous network activity detected. Monitor connection logs closely."
+            }
+        else:
+            return {
+                "risk_level": "Low",
+                "recommendation": "Low risk anomaly. Monitor for further suspicious patterns."
+            }
+
+
+def get_malware_threat_details(prediction: str, confidence: float):
+    """
+    Maps a prediction string and confidence score to a Risk Level and Recommendation.
+    """
+    pred_lower = str(prediction).lower()
+    
+    if "benign" in pred_lower or "normal" in pred_lower:
+        return {
+            "risk_level": "Low",
+            "recommendation": "File appears safe. No malicious signatures or behavior patterns identified."
+        }
+    elif "ransomware" in pred_lower:
+        return {
+            "risk_level": "Critical",
+            "recommendation": "Ransomware signature detected! Immediately isolate the system from all local networks and internet, disable shared drives, and restore from cold backups."
+        }
+    elif "trojan" in pred_lower or "spyware" in pred_lower or "adware" in pred_lower or "backdoor" in pred_lower:
+        return {
+            "risk_level": "High",
+            "recommendation": "Malicious code detected. Place the file in quarantine, run an endpoint security scan, and review running processes."
+        }
+    elif "virus" in pred_lower or "worm" in pred_lower:
+        return {
+            "risk_level": "High",
+            "recommendation": "Self-replicating malware detected. Terminate associated processes, delete the source file, and check network propagation logs."
+        }
+    else:
+        # General default mapping based on confidence
+        if confidence > 0.8:
+            return {
+                "risk_level": "High",
+                "recommendation": "Unclassified threat detected with high confidence. Quarantine the file and analyze in a sandbox environment."
+            }
+        elif confidence > 0.5:
+            return {
+                "risk_level": "Medium",
+                "recommendation": "Suspicious file characteristics detected. Flag for security administrator verification."
+            }
+        else:
+            return {
+                "risk_level": "Low",
+                "recommendation": "Low-confidence file alert. Keep endpoint protection updated."
+            }

venv/.gitignore

@@ -0,0 +1,2 @@
+# Created by venv; see https://docs.python.org/3/library/venv.html
+*

venv/Lib/site-packages/__pycache__/typing_extensions.cpython-314.pyc

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8e386441848b0e94cef78a4872eca4b168f308cc308129e11c86bda1192176b8
+size 179417

venv/Lib/site-packages/annotated_doc-0.0.5.dist-info/INSTALLER

@@ -0,0 +1 @@
+pip

venv/Lib/site-packages/annotated_doc-0.0.5.dist-info/METADATA

@@ -0,0 +1,144 @@
+Metadata-Version: 2.4
+Name: annotated-doc
+Version: 0.0.5
+Summary: Document parameters, class attributes, return types, and variables inline, with Annotated.
+Author-Email: =?utf-8?q?Sebasti=C3=A1n_Ram=C3=ADrez?= <tiangolo@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Intended Audience :: Information Technology
+Classifier: Intended Audience :: System Administrators
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python
+Classifier: Topic :: Internet
+Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development
+Classifier: Typing :: Typed
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Project-URL: Homepage, https://github.com/fastapi/annotated-doc
+Project-URL: Documentation, https://github.com/fastapi/annotated-doc
+Project-URL: Repository, https://github.com/fastapi/annotated-doc
+Project-URL: Issues, https://github.com/fastapi/annotated-doc/issues
+Project-URL: Changelog, https://github.com/fastapi/annotated-doc/release-notes.md
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# Annotated Doc
+
+Document parameters, class attributes, return types, and variables inline, with `Annotated`.
+
+<a href="https://github.com/fastapi/annotated-doc/actions?query=workflow%3ATest+event%3Apush+branch%3Amain" target="_blank">
+    <img src="https://github.com/fastapi/annotated-doc/actions/workflows/test.yml/badge.svg?event=push&branch=main" alt="Test">
+</a>
+<a href="https://coverage-badge.samuelcolvin.workers.dev/redirect/fastapi/annotated-doc" target="_blank">
+    <img src="https://coverage-badge.samuelcolvin.workers.dev/fastapi/annotated-doc.svg" alt="Coverage">
+</a>
+<a href="https://pypi.org/project/annotated-doc" target="_blank">
+    <img src="https://img.shields.io/pypi/v/annotated-doc?color=%2334D058&label=pypi%20package" alt="Package version">
+</a>
+<a href="https://pypi.org/project/annotated-doc" target="_blank">
+    <img src="https://img.shields.io/pypi/pyversions/annotated-doc.svg?color=%2334D058" alt="Supported Python versions">
+</a>
+
+## Installation
+
+```bash
+pip install annotated-doc
+```
+
+Or with `uv`:
+
+```Python
+uv add annotated-doc
+```
+
+## Usage
+
+Import `Doc` and pass a single literal string with the documentation for the specific parameter, class attribute, return type, or variable.
+
+For example, to document a parameter `name` in a function `hi` you could do:
+
+```Python
+from typing import Annotated
+
+from annotated_doc import Doc
+
+def hi(name: Annotated[str, Doc("Who to say hi to")]) -> None:
+    print(f"Hi, {name}!")
+```
+
+You can also use it to document class attributes:
+
+```Python
+from typing import Annotated
+
+from annotated_doc import Doc
+
+class User:
+    name: Annotated[str, Doc("The user's name")]
+    age: Annotated[int, Doc("The user's age")]
+```
+
+The same way, you could document return types and variables, or anything that could have a type annotation with `Annotated`.
+
+## Who Uses This
+
+`annotated-doc` was made for:
+
+* [FastAPI](https://fastapi.tiangolo.com/)
+* [Typer](https://typer.tiangolo.com/)
+* [SQLModel](https://sqlmodel.tiangolo.com/)
+* [Asyncer](https://asyncer.tiangolo.com/)
+
+`annotated-doc` is supported by [griffe-typingdoc](https://github.com/mkdocstrings/griffe-typingdoc), which powers reference documentation like the one in the [FastAPI Reference](https://fastapi.tiangolo.com/reference/).
+
+## Reasons not to use `annotated-doc`
+
+You are already comfortable with one of the existing docstring formats, like:
+
+* Sphinx
+* numpydoc
+* Google
+* Keras
+
+Your team is already comfortable using them.
+
+You prefer having the documentation about parameters all together in a docstring, separated from the code defining them.
+
+You care about a specific set of users, using one specific editor, and that editor already has support for the specific docstring format you use.
+
+## Reasons to use `annotated-doc`
+
+* No micro-syntax to learn for newcomers, it’s **just Python** syntax.
+* **Editing** would be already fully supported by default by any editor (current or future) supporting Python syntax, including syntax errors, syntax highlighting, etc.
+* **Rendering** would be relatively straightforward to implement by static tools (tools that don't need runtime execution), as the information can be extracted from the AST they normally already create.
+* **Deduplication of information**: the name of a parameter would be defined in a single place, not duplicated inside of a docstring.
+* **Elimination** of the possibility of having **inconsistencies** when removing a parameter or class variable and **forgetting to remove** its documentation.
+* **Minimization** of the probability of adding a new parameter or class variable and **forgetting to add its documentation**.
+* **Elimination** of the possibility of having **inconsistencies** between the **name** of a parameter in the **signature** and the name in the docstring when it is renamed.
+* **Access** to the documentation string for each symbol at **runtime**, including existing (older) Python versions.
+* A more formalized way to document other symbols, like type aliases, that could use Annotated.
+* **Support** for apps using FastAPI, Typer and others.
+* **AI Accessibility**: AI tools will have an easier way understanding each parameter as the distance from documentation to parameter is much closer.
+
+## History
+
+I ([@tiangolo](https://github.com/tiangolo)) originally wanted for this to be part of the Python standard library (in [PEP 727](https://peps.python.org/pep-0727/)), but the proposal was withdrawn as there was a fair amount of negative feedback and opposition.
+
+The conclusion was that this was better done as an external effort, in a third-party library.
+
+So, here it is, with a simpler approach, as a third-party library, in a way that can be used by others, starting with FastAPI and friends.
+
+## License
+
+This project is licensed under the terms of the MIT license.

venv/Lib/site-packages/annotated_doc-0.0.5.dist-info/RECORD

@@ -0,0 +1,11 @@
+annotated_doc-0.0.5.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+annotated_doc-0.0.5.dist-info/METADATA,sha256=jCTXDF2RU9IhIzU6kGBC_XYD3y0VwhlikLD4qWJVjEY,6516
+annotated_doc-0.0.5.dist-info/RECORD,,
+annotated_doc-0.0.5.dist-info/WHEEL,sha256=VP-D4TPS230sME9Z3vb3INXvo1yt0924YRm5AOsk_dE,90
+annotated_doc-0.0.5.dist-info/entry_points.txt,sha256=6OYgBcLyFCUgeqLgnvMyOJxPCWzgy7se4rLPKtNonMs,34
+annotated_doc-0.0.5.dist-info/licenses/LICENSE,sha256=__Fwd5pqy_ZavbQFwIfxzuF4ZpHkqWpANFF-SlBKDN8,1086
+annotated_doc/__init__.py,sha256=UqEV5evgeySQ5yvJQwfwTqwvMGfIwbxRPP4gf-o2-LA,52
+annotated_doc/__pycache__/__init__.cpython-314.pyc,,
+annotated_doc/__pycache__/main.cpython-314.pyc,,
+annotated_doc/main.py,sha256=5Zfvxv80SwwLqpRW73AZyZyiM4bWma9QWRbp_cgD20s,1075
+annotated_doc/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0

venv/Lib/site-packages/annotated_doc-0.0.5.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: pdm-backend (2.4.9)
+Root-Is-Purelib: true
+Tag: py3-none-any

venv/Lib/site-packages/annotated_doc-0.0.5.dist-info/entry_points.txt

@@ -0,0 +1,4 @@
+[console_scripts]
+
+[gui_scripts]
+

venv/Lib/site-packages/annotated_doc-0.0.5.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 Sebastián Ramírez
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

venv/Lib/site-packages/annotated_doc/__init__.py

@@ -0,0 +1,3 @@
+from .main import Doc as Doc
+
+__version__ = "0.0.5"

venv/Lib/site-packages/annotated_doc/main.py

@@ -0,0 +1,36 @@
+class Doc:
+    """Define the documentation of a type annotation using `Annotated`, to be
+        used in class attributes, function and method parameters, return values,
+        and variables.
+
+    The value should be a positional-only string literal to allow static tools
+    like editors and documentation generators to use it.
+
+    This complements docstrings.
+
+    The string value passed is available in the attribute `documentation`.
+
+    Example:
+
+    ```Python
+    from typing import Annotated
+    from annotated_doc import Doc
+
+    def hi(name: Annotated[str, Doc("Who to say hi to")]) -> None:
+        print(f"Hi, {name}!")
+    ```
+    """
+
+    def __init__(self, documentation: str, /) -> None:
+        self.documentation = documentation
+
+    def __repr__(self) -> str:
+        return f"Doc({self.documentation!r})"
+
+    def __hash__(self) -> int:
+        return hash(self.documentation)
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, Doc):
+            return NotImplemented
+        return self.documentation == other.documentation

venv/Lib/site-packages/annotated_types-0.8.0.dist-info/INSTALLER

@@ -0,0 +1 @@
+pip

venv/Lib/site-packages/annotated_types-0.8.0.dist-info/METADATA

@@ -0,0 +1,295 @@
+Metadata-Version: 2.4
+Name: annotated-types
+Version: 0.8.0
+Summary: Reusable constraint types to use with typing.Annotated
+Project-URL: Homepage, https://github.com/annotated-types/annotated-types
+Project-URL: Source, https://github.com/annotated-types/annotated-types
+Project-URL: Changelog, https://github.com/annotated-types/annotated-types/releases
+Author-email: Adrian Garcia Badaracco <1755071+adriangb@users.noreply.github.com>, Samuel Colvin <s@muelcolvin.com>, Zac Hatfield-Dodds <zac@zhd.dev>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Environment :: MacOS X
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Information Technology
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: Unix
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# annotated-types
+
+[![CI](https://github.com/annotated-types/annotated-types/workflows/CI/badge.svg?event=push)](https://github.com/annotated-types/annotated-types/actions?query=event%3Apush+branch%3Amain+workflow%3ACI)
+[![pypi](https://img.shields.io/pypi/v/annotated-types.svg)](https://pypi.python.org/pypi/annotated-types)
+[![versions](https://img.shields.io/pypi/pyversions/annotated-types.svg)](https://github.com/annotated-types/annotated-types)
+[![license](https://img.shields.io/github/license/annotated-types/annotated-types.svg)](https://github.com/annotated-types/annotated-types/blob/main/LICENSE)
+
+[PEP-593](https://peps.python.org/pep-0593/) added `typing.Annotated` as a way of
+adding context-specific metadata to existing types, and specifies that
+`Annotated[T, x]` _should_ be treated as `T` by any tool or library without special
+logic for `x`.
+
+This package provides metadata objects which can be used to represent common
+constraints such as upper and lower bounds on scalar values and collection sizes,
+a `Predicate` marker for runtime checks, and
+descriptions of how we intend these metadata to be interpreted. In some cases,
+we also note alternative representations which do not require this package.
+
+## Install
+
+```bash
+pip install annotated-types
+```
+
+## Examples
+
+```python
+from typing import Annotated
+from annotated_types import Gt, Len, Predicate
+
+class MyClass:
+    age: Annotated[int, Gt(18)]                         # Valid: 19, 20, ...
+                                                        # Invalid: 17, 18, "19", 19.0, ...
+    factors: list[Annotated[int, Predicate(is_prime)]]  # Valid: 2, 3, 5, 7, 11, ...
+                                                        # Invalid: 4, 8, -2, 5.0, "prime", ...
+
+    my_list: Annotated[list[int], Len(0, 10)]           # Valid: [], [10, 20, 30, 40, 50]
+                                                        # Invalid: (1, 2), ["abc"], [0] * 20
+```
+
+## Documentation
+
+_While `annotated-types` avoids runtime checks for performance, users should not
+construct invalid combinations such as `MultipleOf("non-numeric")` or `Annotated[int, Len(3)]`.
+Downstream implementors may choose to raise an error, emit a warning, silently ignore
+a metadata item, etc., if the metadata objects described below are used with an
+incompatible type - or for any other reason!_
+
+### Gt, Ge, Lt, Le
+
+Express inclusive and/or exclusive bounds on orderable values - which may be numbers,
+dates, times, strings, sets, etc. Note that the boundary value need not be of the
+same type that was annotated, so long as they can be compared: `Annotated[int, Gt(1.5)]`
+is fine, for example, and implies that the value is an integer x such that `x > 1.5`.
+
+We suggest that implementors may also interpret `functools.partial(operator.le, 1.5)`
+as being equivalent to `Gt(1.5)`, for users who wish to avoid a runtime dependency on
+the `annotated-types` package.
+
+To be explicit, these types have the following meanings:
+
+* `Gt(x)` - value must be "Greater Than" `x` - equivalent to exclusive minimum
+* `Ge(x)` - value must be "Greater than or Equal" to `x` - equivalent to inclusive minimum
+* `Lt(x)` - value must be "Less Than" `x` - equivalent to exclusive maximum
+* `Le(x)` - value must be "Less than or Equal" to `x` - equivalent to inclusive maximum
+
+### Interval
+
+`Interval(gt, ge, lt, le)` allows you to specify an upper and lower bound with a single
+metadata object. `None` attributes should be ignored, and non-`None` attributes
+treated as per the single bounds above.
+
+### MultipleOf
+
+`MultipleOf(multiple_of=x)` might be interpreted in two ways:
+
+1. Python semantics, implying `value % multiple_of == 0`, or
+2. [JSONschema semantics](https://json-schema.org/draft/2020-12/json-schema-validation.html#rfc.section.6.2.1),
+   where `int(value / multiple_of) == value / multiple_of`.
+
+We encourage users to be aware of these two common interpretations and their
+distinct behaviours, especially since very large or non-integer numbers make
+it easy to cause silent data corruption due to floating-point imprecision.
+
+We encourage libraries to carefully document which interpretation they implement.
+
+### MinLen, MaxLen, Len
+
+`Len()` implies that `min_length <= len(value) <= max_length` - lower and upper bounds are inclusive.
+
+As well as `Len()` which can optionally include upper and lower bounds, we also
+provide `MinLen(x)` and `MaxLen(y)` which are equivalent to `Len(min_length=x)`
+and `Len(max_length=y)` respectively.
+
+`Len`, `MinLen`, and `MaxLen` may be used with any type which supports `len(value)`.
+
+Examples of usage:
+
+* `Annotated[list, MaxLen(10)]` (or `Annotated[list, Len(max_length=10)]`) - list must have a length of 10 or less
+* `Annotated[str, MaxLen(10)]` - string must have a length of 10 or less
+* `Annotated[list, MinLen(3)]` (or `Annotated[list, Len(min_length=3)]`) - list must have a length of 3 or more
+* `Annotated[list, Len(4, 6)]` - list must have a length of 4, 5, or 6
+* `Annotated[list, Len(8, 8)]` - list must have a length of exactly 8
+
+#### Changed in v0.4.0
+
+* `min_inclusive` has been renamed to `min_length`, no change in meaning
+* `max_exclusive` has been renamed to `max_length`, upper bound is now **inclusive** instead of **exclusive**
+* The recommendation that slices are interpreted as `Len` has been removed due to ambiguity and different semantic
+  meaning of the upper bound in slices vs. `Len`
+
+See [issue #23](https://github.com/annotated-types/annotated-types/issues/23) for discussion.
+
+### Timezone
+
+`Timezone` can be used with a `datetime` or a `time` to express which timezones
+are allowed. `Annotated[datetime, Timezone(None)]` must be a naive datetime.
+`Timezone[...]` ([literal ellipsis](https://docs.python.org/3/library/constants.html#Ellipsis))
+expresses that any timezone-aware datetime is allowed. You may also pass a specific
+timezone string or [`tzinfo`](https://docs.python.org/3/library/datetime.html#tzinfo-objects)
+object such as `Timezone(timezone.utc)` or `Timezone("Africa/Abidjan")` to express that you only
+allow a specific timezone, though we note that this is often a symptom of fragile design.
+
+#### Changed in v0.x.x
+
+* `Timezone` accepts [`tzinfo`](https://docs.python.org/3/library/datetime.html#tzinfo-objects) objects instead of
+  `timezone`, extending compatibility to [`zoneinfo`](https://docs.python.org/3/library/zoneinfo.html) and third party libraries.
+
+### Unit
+
+`Unit(unit: str)` expresses that the annotated numeric value is the magnitude of
+a quantity with the specified unit. For example, `Annotated[float, Unit("m/s")]`
+would be a float representing a velocity in meters per second.
+
+Please note that `annotated_types` itself makes no attempt to parse or validate
+the unit string in any way. That is left entirely to downstream libraries,
+such as [`pint`](https://pint.readthedocs.io) or
+[`astropy.units`](https://docs.astropy.org/en/stable/units/).
+
+An example of how a library might use this metadata:
+
+```python
+from annotated_types import Unit
+from typing import Annotated, TypeVar, Callable, Any, get_origin, get_args
+
+# given a type annotated with a unit:
+Meters = Annotated[float, Unit("m")]
+
+
+# you can cast the annotation to a specific unit type with any
+# callable that accepts a string and returns the desired type
+T = TypeVar("T")
+def cast_unit(tp: Any, unit_cls: Callable[[str], T]) -> T | None:
+    if get_origin(tp) is Annotated:
+        for arg in get_args(tp):
+            if isinstance(arg, Unit):
+                return unit_cls(arg.unit)
+    return None
+
+
+# using `pint`
+import pint
+pint_unit = cast_unit(Meters, pint.Unit)
+
+
+# using `astropy.units`
+import astropy.units as u
+astropy_unit = cast_unit(Meters, u.Unit)
+```
+
+### Predicate
+
+`Predicate(func: Callable)` expresses that `func(value)` is truthy for valid values.
+Users should prefer the statically inspectable metadata above, but if you need
+the full power and flexibility of arbitrary runtime predicates... here it is.
+
+For some common constraints, we provide generic types:
+
+* `LowerCase     = Annotated[T, Predicate(str.islower)]`
+* `UpperCase     = Annotated[T, Predicate(str.isupper)]`
+* `IsDigit       = Annotated[T, Predicate(str.isdigit)]`
+* `IsFinite      = Annotated[T, Predicate(math.isfinite)]`
+* `IsNotFinite   = Annotated[T, Predicate(Not(math.isfinite))]`
+* `IsNan         = Annotated[T, Predicate(math.isnan)]`
+* `IsNotNan      = Annotated[T, Predicate(Not(math.isnan))]`
+* `IsInfinite    = Annotated[T, Predicate(math.isinf)]`
+* `IsNotInfinite = Annotated[T, Predicate(Not(math.isinf))]`
+
+so that you can write e.g. `x: IsFinite[float] = 2.0` instead of the longer
+(but exactly equivalent) `x: Annotated[float, Predicate(math.isfinite)] = 2.0`.
+
+Some libraries might have special logic to handle known or understandable predicates,
+for example by checking for `str.isdigit` and using its presence to both call custom
+logic to enforce digit-only strings, and customise some generated external schema.
+Users are therefore encouraged to avoid indirection like `lambda s: s.lower()`, in
+favor of introspectable methods such as `str.lower` or `re.compile("pattern").search`.
+
+To enable basic negation of commonly used predicates like `math.isnan` without introducing introspection that makes it impossible for implementers to introspect the predicate we provide a `Not` wrapper that simply negates the predicate in an introspectable manner. Several of the predicates listed above are created in this manner.
+
+We do not specify what behaviour should be expected for predicates that raise
+an exception.  For example `Annotated[int, Predicate(str.isdigit)]` might silently
+skip invalid constraints, or statically raise an error; or it might try calling it
+and then propagate or discard the resulting
+`TypeError: descriptor 'isdigit' for 'str' objects doesn't apply to a 'int' object`
+exception.  We encourage libraries to document the behaviour they choose.
+
+### Doc
+
+`doc()` can be used to add documentation information in `Annotated`, for function and method parameters, variables, class attributes, return types, and any place where `Annotated` can be used.
+
+It expects a value that can be statically analyzed, as the main use case is for static analysis, editors, documentation generators, and similar tools.
+
+It returns a `DocInfo` class with a single attribute `documentation` containing the value passed to `doc()`.
+
+This is the early adopter's alternative form of the [`typing-doc` proposal](https://github.com/tiangolo/fastapi/blob/typing-doc/typing_doc.md).
+
+### Integrating downstream types with `GroupedMetadata`
+
+Implementers may choose to provide a convenience wrapper that groups multiple pieces of metadata.
+This can help reduce verbosity and cognitive overhead for users.
+For example, an implementer like Pydantic might provide a `Field` or `Meta` type that accepts keyword arguments and transforms these into low-level metadata:
+
+```python
+from dataclasses import dataclass
+from typing import Iterator
+from annotated_types import GroupedMetadata, Ge
+
+@dataclass
+class Field(GroupedMetadata):
+    ge: int | None = None
+    description: str | None = None
+
+    def __iter__(self) -> Iterator[object]:
+        # Iterating over a GroupedMetadata object should yield annotated-types
+        # constraint metadata objects which describe it as fully as possible,
+        # and may include other unknown objects too.
+        if self.ge is not None:
+            yield Ge(self.ge)
+        if self.description is not None:
+            yield Description(self.description)
+```
+
+Libraries consuming annotated-types constraints should check for `GroupedMetadata` and unpack it by iterating over the object and treating the results as if they had been "unpacked" in the `Annotated` type.  The same logic should be applied to the [PEP 646 `Unpack` type](https://peps.python.org/pep-0646/), so that `Annotated[T, Field(...)]`, `Annotated[T, Unpack[Field(...)]]` and `Annotated[T, *Field(...)]` are all treated consistently.
+
+Libraries consuming annotated-types should also ignore any metadata they do not recongize that came from unpacking a `GroupedMetadata`, just like they ignore unrecognized metadata in `Annotated` itself.
+
+Our own `annotated_types.Interval` class is a `GroupedMetadata` which unpacks itself into `Gt`, `Lt`, etc., so this is not an abstract concern.  Similarly, `annotated_types.Len` is a `GroupedMetadata` which unpacks itself into `MinLen` (optionally) and `MaxLen`.
+
+### Consuming metadata
+
+We intend to not be prescriptive as to _how_ the metadata and constraints are used, but as an example of how one might parse constraints from types annotations see our [implementation in `test_main.py`](https://github.com/annotated-types/annotated-types/blob/f59cf6d1b5255a0fe359b93896759a180bec30ae/tests/test_main.py#L94-L103).
+
+It is up to the implementer to determine how this metadata is used.
+You could use the metadata for runtime type checking, for generating schemas or to generate example data, amongst other use cases.
+
+## Design & History
+
+This package was designed at the PyCon 2022 sprints by the maintainers of Pydantic
+and Hypothesis, with the goal of making it as easy as possible for end-users to
+provide more informative annotations for use by runtime libraries.
+
+It is deliberately minimal, and following PEP-593 allows considerable downstream
+discretion in what (if anything!) they choose to support. Nonetheless, we expect
+that staying simple and covering _only_ the most common use-cases will give users
+and maintainers the best experience we can. If you'd like more constraints for your
+types - follow our lead, by defining them and documenting them downstream!

venv/Lib/site-packages/annotated_types-0.8.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+annotated_types-0.8.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+annotated_types-0.8.0.dist-info/METADATA,sha256=YUmFsnj2Abjvhj-CeDuZHMOtpLifWS63HHxIxfLvIpg,15009
+annotated_types-0.8.0.dist-info/RECORD,,
+annotated_types-0.8.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+annotated_types-0.8.0.dist-info/licenses/LICENSE,sha256=_hBJiEsaDZNCkB6I4H8ykl0ksxIdmXK2poBfuYJLCV0,1083
+annotated_types/__init__.py,sha256=pxBKTUObJ6n3T8C-I2ubobeDHmBEAmgCogWrwSmKm8g,13273
+annotated_types/__pycache__/__init__.cpython-314.pyc,,
+annotated_types/__pycache__/test_cases.cpython-314.pyc,,
+annotated_types/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+annotated_types/test_cases.py,sha256=2GdHKstXuBzpf3iXKCjmvFZpyk2zP9Hm9kXGGDhGBo4,6310

venv/Lib/site-packages/annotated_types-0.8.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.31.0
+Root-Is-Purelib: true
+Tag: py3-none-any

venv/Lib/site-packages/annotated_types-0.8.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2022 the contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

venv/Lib/site-packages/annotated_types/__init__.py

@@ -0,0 +1,416 @@
+import math
+import types
+from collections.abc import Callable, Iterator
+from dataclasses import dataclass
+from datetime import tzinfo
+from types import EllipsisType
+from typing import (
+    TYPE_CHECKING,
+    Annotated,
+    Any,
+    Literal,
+    Protocol,
+    SupportsFloat,
+    SupportsIndex,
+    TypeVar,
+    Union,
+    runtime_checkable,
+)
+
+__all__ = (
+    'BaseMetadata',
+    'GroupedMetadata',
+    'Gt',
+    'Ge',
+    'Lt',
+    'Le',
+    'Interval',
+    'MultipleOf',
+    'MinLen',
+    'MaxLen',
+    'Len',
+    'Timezone',
+    'Predicate',
+    'LowerCase',
+    'UpperCase',
+    'IsDigits',
+    'IsFinite',
+    'IsNotFinite',
+    'IsNan',
+    'IsNotNan',
+    'IsInfinite',
+    'IsNotInfinite',
+    'doc',
+    'DocInfo',
+    '__version__',
+)
+
+__version__ = '0.8.0'
+
+
+T = TypeVar('T')
+
+
+# arguments that start with __ are considered
+# positional only
+# see https://peps.python.org/pep-0484/#positional-only-arguments
+
+
+class SupportsGt(Protocol):
+    def __gt__(self: T, __other: T) -> bool:
+        ...
+
+
+class SupportsGe(Protocol):
+    def __ge__(self: T, __other: T) -> bool:
+        ...
+
+
+class SupportsLt(Protocol):
+    def __lt__(self: T, __other: T) -> bool:
+        ...
+
+
+class SupportsLe(Protocol):
+    def __le__(self: T, __other: T) -> bool:
+        ...
+
+
+class SupportsMod(Protocol):
+    def __mod__(self: T, __other: T) -> T:
+        ...
+
+
+class SupportsDiv(Protocol):
+    def __div__(self: T, __other: T) -> T:
+        ...
+
+
+class BaseMetadata:
+    """Base class for all metadata.
+
+    This exists mainly so that implementers
+    can do `isinstance(..., BaseMetadata)` while traversing field annotations.
+    """
+
+    __slots__ = ()
+
+
+@dataclass(frozen=True, slots=True)
+class Gt(BaseMetadata):
+    """Gt(gt=x) implies that the value must be greater than x.
+
+    It can be used with any type that supports the ``>`` operator,
+    including numbers, dates and times, strings, sets, and so on.
+    """
+
+    gt: SupportsGt
+
+
+@dataclass(frozen=True, slots=True)
+class Ge(BaseMetadata):
+    """Ge(ge=x) implies that the value must be greater than or equal to x.
+
+    It can be used with any type that supports the ``>=`` operator,
+    including numbers, dates and times, strings, sets, and so on.
+    """
+
+    ge: SupportsGe
+
+
+@dataclass(frozen=True, slots=True)
+class Lt(BaseMetadata):
+    """Lt(lt=x) implies that the value must be less than x.
+
+    It can be used with any type that supports the ``<`` operator,
+    including numbers, dates and times, strings, sets, and so on.
+    """
+
+    lt: SupportsLt
+
+
+@dataclass(frozen=True, slots=True)
+class Le(BaseMetadata):
+    """Le(le=x) implies that the value must be less than or equal to x.
+
+    It can be used with any type that supports the ``<=`` operator,
+    including numbers, dates and times, strings, sets, and so on.
+    """
+
+    le: SupportsLe
+
+
+@runtime_checkable
+class GroupedMetadata(Protocol):
+    """A grouping of multiple objects, like typing.Unpack.
+
+    `GroupedMetadata` on its own is not metadata and has no meaning.
+    All of the constraints and metadata should be fully expressable
+    in terms of the `BaseMetadata`'s returned by `GroupedMetadata.__iter__()`.
+
+    Concrete implementations should override `GroupedMetadata.__iter__()`
+    to add their own metadata.
+    For example:
+
+    >>> @dataclass
+    >>> class Field(GroupedMetadata):
+    >>>     gt: float | None = None
+    >>>     description: str | None = None
+    ...
+    >>>     def __iter__(self) -> Iterable[object]:
+    >>>         if self.gt is not None:
+    >>>             yield Gt(self.gt)
+    >>>         if self.description is not None:
+    >>>             yield Description(self.gt)
+
+    Also see the implementation of `Interval` below for an example.
+
+    Parsers should recognize this and unpack it so that it can be used
+    both with and without unpacking:
+
+    - `Annotated[int, Field(...)]` (parser must unpack Field)
+    - `Annotated[int, *Field(...)]` (PEP-646)
+    """  # noqa: trailing-whitespace
+
+    @property
+    def __is_annotated_types_grouped_metadata__(self) -> Literal[True]:
+        return True
+
+    def __iter__(self) -> Iterator[object]:
+        ...
+
+    if not TYPE_CHECKING:
+        __slots__ = ()  # allow subclasses to use slots
+
+        def __init_subclass__(cls, *args: Any, **kwargs: Any) -> None:
+            # Basic ABC like functionality without the complexity of an ABC
+            super().__init_subclass__(*args, **kwargs)
+            if cls.__iter__ is GroupedMetadata.__iter__:
+                raise TypeError("Can't subclass GroupedMetadata without implementing __iter__")
+
+        def __iter__(self) -> Iterator[object]:  # noqa: F811
+            raise NotImplementedError  # more helpful than "None has no attribute..." type errors
+
+
+@dataclass(frozen=True, kw_only=True, slots=True)
+class Interval(GroupedMetadata):
+    """Interval can express inclusive or exclusive bounds with a single object.
+
+    It accepts keyword arguments ``gt``, ``ge``, ``lt``, and/or ``le``, which
+    are interpreted the same way as the single-bound constraints.
+    """
+
+    gt: SupportsGt | None = None
+    ge: SupportsGe | None = None
+    lt: SupportsLt | None = None
+    le: SupportsLe | None = None
+
+    def __iter__(self) -> Iterator[BaseMetadata]:
+        """Unpack an Interval into zero or more single-bounds."""
+        if self.gt is not None:
+            yield Gt(self.gt)
+        if self.ge is not None:
+            yield Ge(self.ge)
+        if self.lt is not None:
+            yield Lt(self.lt)
+        if self.le is not None:
+            yield Le(self.le)
+
+
+@dataclass(frozen=True, slots=True)
+class MultipleOf(BaseMetadata):
+    """MultipleOf(multiple_of=x) might be interpreted in two ways:
+
+    1. Python semantics, implying ``value % multiple_of == 0``, or
+    2. JSONschema semantics, where ``int(value / multiple_of) == value / multiple_of``
+
+    We encourage users to be aware of these two common interpretations,
+    and libraries to carefully document which they implement.
+    """
+
+    multiple_of: SupportsDiv | SupportsMod
+
+
+@dataclass(frozen=True, slots=True)
+class MinLen(BaseMetadata):
+    """
+    MinLen() implies minimum inclusive length,
+    e.g. ``len(value) >= min_length``.
+    """
+
+    min_length: Annotated[int, Ge(0)]
+
+
+@dataclass(frozen=True, slots=True)
+class MaxLen(BaseMetadata):
+    """
+    MaxLen() implies maximum inclusive length,
+    e.g. ``len(value) <= max_length``.
+    """
+
+    max_length: Annotated[int, Ge(0)]
+
+
+@dataclass(frozen=True, slots=True)
+class Len(GroupedMetadata):
+    """
+    Len() implies that ``min_length <= len(value) <= max_length``.
+
+    Upper bound may be omitted or ``None`` to indicate no upper length bound.
+    """
+
+    min_length: Annotated[int, Ge(0)] = 0
+    max_length: Annotated[int, Ge(0)] | None = None
+
+    def __iter__(self) -> Iterator[BaseMetadata]:
+        """Unpack a Len into zero or more single-bounds."""
+        if self.min_length > 0:
+            yield MinLen(self.min_length)
+        if self.max_length is not None:
+            yield MaxLen(self.max_length)
+
+
+@dataclass(frozen=True, slots=True)
+class Timezone(BaseMetadata):
+    """Timezone(tz=...) requires a datetime to be aware (or ``tz=None``, naive).
+
+    ``Annotated[datetime, Timezone(None)]`` must be a naive datetime.
+    ``Timezone(...)`` (the ellipsis literal) expresses that the datetime must be
+    tz-aware but any timezone is allowed.
+
+    You may also pass a specific timezone string or tzinfo object such as
+    ``Timezone(timezone.utc)`` or ``Timezone("Africa/Abidjan")`` to express that
+    you only allow a specific timezone, though we note that this is often
+    a symptom of poor design.
+    """
+
+    tz: str | tzinfo | EllipsisType | None
+
+
+@dataclass(frozen=True, slots=True)
+class Unit(BaseMetadata):
+    """Indicates that the value is a physical quantity with the specified unit.
+
+    It is intended for usage with numeric types, where the value represents the
+    magnitude of the quantity. For example, ``distance: Annotated[float, Unit('m')]``
+    or ``speed: Annotated[float, Unit('m/s')]``.
+
+    Interpretation of the unit string is left to the discretion of the consumer.
+    It is suggested to follow conventions established by python libraries that work
+    with physical quantities, such as
+
+    - ``pint`` : <https://pint.readthedocs.io/en/stable/>
+    - ``astropy.units``: <https://docs.astropy.org/en/stable/units/>
+
+    For indicating a quantity with a certain dimensionality but without a specific unit
+    it is recommended to use square brackets, e.g. `Annotated[float, Unit('[time]')]`.
+    Note, however, ``annotated_types`` itself makes no use of the unit string.
+    """
+
+    unit: str
+
+
+@dataclass(frozen=True, slots=True)
+class Predicate(BaseMetadata):
+    """``Predicate(func: Callable)`` implies `func(value)` is truthy for valid values.
+
+    Users should prefer statically inspectable metadata, but if you need the full
+    power and flexibility of arbitrary runtime predicates... here it is.
+
+    We provide a few predefined predicates for common string constraints:
+    ``LowerCase = Predicate(str.islower)``, ``UpperCase = Predicate(str.isupper)``, and
+    ``IsDigits = Predicate(str.isdigit)``. Users are encouraged to use methods which
+    can be given special handling, and avoid indirection like ``lambda s: s.lower()``.
+
+    Some libraries might have special logic to handle certain predicates, e.g. by
+    checking for `str.isdigit` and using its presence to both call custom logic to
+    enforce digit-only strings, and customise some generated external schema.
+
+    We do not specify what behaviour should be expected for predicates that raise
+    an exception.  For example `Annotated[int, Predicate(str.isdigit)]` might silently
+    skip invalid constraints, or statically raise an error; or it might try calling it
+    and then propagate or discard the resulting exception.
+    """
+
+    func: Callable[[Any], bool]
+
+    def __repr__(self) -> str:
+        if getattr(self.func, "__name__", "<lambda>") == "<lambda>":
+            return f"{self.__class__.__name__}({self.func!r})"
+        if isinstance(self.func, (types.MethodType, types.BuiltinMethodType)) and (
+            namespace := getattr(self.func.__self__, "__name__", None)
+        ):
+            return f"{self.__class__.__name__}({namespace}.{self.func.__name__})"
+        if isinstance(self.func, type(str.isascii)):  # method descriptor
+            return f"{self.__class__.__name__}({self.func.__qualname__})"
+        return f"{self.__class__.__name__}({self.func.__name__})"
+
+
+@dataclass
+class Not:
+    func: Callable[[Any], bool]
+
+    def __call__(self, __v: Any) -> bool:
+        return not self.func(__v)
+
+
+_StrType = TypeVar("_StrType", bound=str)
+
+LowerCase = Annotated[_StrType, Predicate(str.islower)]
+"""
+Return True if the string is a lowercase string, False otherwise.
+
+A string is lowercase if all cased characters in the string are lowercase and there is at least one cased character in the string.
+"""  # noqa: E501
+UpperCase = Annotated[_StrType, Predicate(str.isupper)]
+"""
+Return True if the string is an uppercase string, False otherwise.
+
+A string is uppercase if all cased characters in the string are uppercase and there is at least one cased character in the string.
+"""  # noqa: E501
+IsDigit = Annotated[_StrType, Predicate(str.isdigit)]
+IsDigits = IsDigit  # type: ignore  # plural for backwards compatibility, see #63
+"""
+Return True if the string is a digit string, False otherwise.
+
+A string is a digit string if all characters in the string are digits and there is at least one character in the string.
+"""  # noqa: E501
+IsAscii = Annotated[_StrType, Predicate(str.isascii)]
+"""
+Return True if all characters in the string are ASCII, False otherwise.
+
+ASCII characters have code points in the range U+0000-U+007F. Empty string is ASCII too.
+"""
+
+_NumericType = TypeVar('_NumericType', bound=Union[SupportsFloat, SupportsIndex])
+IsFinite = Annotated[_NumericType, Predicate(math.isfinite)]
+"""Return True if x is neither an infinity nor a NaN, and False otherwise."""
+IsNotFinite = Annotated[_NumericType, Predicate(Not(math.isfinite))]
+"""Return True if x is one of infinity or NaN, and False otherwise"""
+IsNan = Annotated[_NumericType, Predicate(math.isnan)]
+"""Return True if x is a NaN (not a number), and False otherwise."""
+IsNotNan = Annotated[_NumericType, Predicate(Not(math.isnan))]
+"""Return True if x is anything but NaN (not a number), and False otherwise."""
+IsInfinite = Annotated[_NumericType, Predicate(math.isinf)]
+"""Return True if x is a positive or negative infinity, and False otherwise."""
+IsNotInfinite = Annotated[_NumericType, Predicate(Not(math.isinf))]
+"""Return True if x is neither a positive or negative infinity, and False otherwise."""
+
+try:
+    # PEP 727 – Documentation in Annotated Metadata
+    from typing_extensions import Doc  # type: ignore[attr-defined]
+except ImportError:
+
+    @dataclass(frozen=True, slots=True)
+    class Doc:  # type: ignore [no-redef]
+        """ "
+        The return value of doc(), mainly to be used by tools that want to extract the
+        Annotated documentation at runtime.
+        """
+
+        documentation: str
+        """The documentation string passed to doc()."""
+
+
+DocInfo = Doc  # backwards compatibility
+doc = Doc

venv/Lib/site-packages/annotated_types/test_cases.py

@@ -0,0 +1,146 @@
+import math
+from collections.abc import Iterable, Iterator
+from datetime import date, datetime, timedelta, timezone
+from decimal import Decimal
+from typing import Annotated, Any, NamedTuple
+
+import annotated_types as at
+
+
+class Case(NamedTuple):
+    """
+    A test case for `annotated_types`.
+    """
+
+    annotation: Any
+    valid_cases: Iterable[Any]
+    invalid_cases: Iterable[Any]
+
+
+def cases() -> Iterable[Case]:
+    # Gt, Ge, Lt, Le
+    yield Case(Annotated[int, at.Gt(4)], (5, 6, 1000), (4, 0, -1))
+    yield Case(Annotated[float, at.Gt(0.5)], (0.6, 0.7, 0.8, 0.9), (0.5, 0.0, -0.1))
+    yield Case(
+        Annotated[datetime, at.Gt(datetime(2000, 1, 1))],
+        [datetime(2000, 1, 2), datetime(2000, 1, 3)],
+        [datetime(2000, 1, 1), datetime(1999, 12, 31)],
+    )
+    yield Case(
+        Annotated[datetime, at.Gt(date(2000, 1, 1))],
+        [date(2000, 1, 2), date(2000, 1, 3)],
+        [date(2000, 1, 1), date(1999, 12, 31)],
+    )
+    yield Case(
+        Annotated[datetime, at.Gt(Decimal('1.123'))],
+        [Decimal('1.1231'), Decimal('123')],
+        [Decimal('1.123'), Decimal('0')],
+    )
+
+    yield Case(Annotated[int, at.Ge(4)], (4, 5, 6, 1000, 4), (0, -1))
+    yield Case(Annotated[float, at.Ge(0.5)], (0.5, 0.6, 0.7, 0.8, 0.9), (0.4, 0.0, -0.1))
+    yield Case(
+        Annotated[datetime, at.Ge(datetime(2000, 1, 1))],
+        [datetime(2000, 1, 2), datetime(2000, 1, 3)],
+        [datetime(1998, 1, 1), datetime(1999, 12, 31)],
+    )
+
+    yield Case(Annotated[int, at.Lt(4)], (0, -1), (4, 5, 6, 1000, 4))
+    yield Case(Annotated[float, at.Lt(0.5)], (0.4, 0.0, -0.1), (0.5, 0.6, 0.7, 0.8, 0.9))
+    yield Case(
+        Annotated[datetime, at.Lt(datetime(2000, 1, 1))],
+        [datetime(1999, 12, 31), datetime(1999, 12, 31)],
+        [datetime(2000, 1, 2), datetime(2000, 1, 3)],
+    )
+
+    yield Case(Annotated[int, at.Le(4)], (4, 0, -1), (5, 6, 1000))
+    yield Case(Annotated[float, at.Le(0.5)], (0.5, 0.0, -0.1), (0.6, 0.7, 0.8, 0.9))
+    yield Case(
+        Annotated[datetime, at.Le(datetime(2000, 1, 1))],
+        [datetime(2000, 1, 1), datetime(1999, 12, 31)],
+        [datetime(2000, 1, 2), datetime(2000, 1, 3)],
+    )
+
+    # Interval
+    yield Case(Annotated[int, at.Interval(gt=4)], (5, 6, 1000), (4, 0, -1))
+    yield Case(Annotated[int, at.Interval(gt=4, lt=10)], (5, 6), (4, 10, 1000, 0, -1))
+    yield Case(Annotated[float, at.Interval(ge=0.5, le=1)], (0.5, 0.9, 1), (0.49, 1.1))
+    yield Case(
+        Annotated[datetime, at.Interval(gt=datetime(2000, 1, 1), le=datetime(2000, 1, 3))],
+        [datetime(2000, 1, 2), datetime(2000, 1, 3)],
+        [datetime(2000, 1, 1), datetime(2000, 1, 4)],
+    )
+
+    yield Case(Annotated[int, at.MultipleOf(multiple_of=3)], (0, 3, 9), (1, 2, 4))
+    yield Case(Annotated[float, at.MultipleOf(multiple_of=0.5)], (0, 0.5, 1, 1.5), (0.4, 1.1))
+
+    # lengths
+
+    yield Case(Annotated[str, at.MinLen(3)], ('123', '1234', 'x' * 10), ('', '1', '12'))
+    yield Case(Annotated[str, at.Len(3)], ('123', '1234', 'x' * 10), ('', '1', '12'))
+    yield Case(Annotated[list[int], at.MinLen(3)], ([1, 2, 3], [1, 2, 3, 4], [1] * 10), ([], [1], [1, 2]))
+    yield Case(Annotated[list[int], at.Len(3)], ([1, 2, 3], [1, 2, 3, 4], [1] * 10), ([], [1], [1, 2]))
+
+    yield Case(Annotated[str, at.MaxLen(4)], ('', '1234'), ('12345', 'x' * 10))
+    yield Case(Annotated[str, at.Len(0, 4)], ('', '1234'), ('12345', 'x' * 10))
+    yield Case(Annotated[list[str], at.MaxLen(4)], ([], ['a', 'bcdef'], ['a', 'b', 'c']), (['a'] * 5, ['b'] * 10))
+    yield Case(Annotated[list[str], at.Len(0, 4)], ([], ['a', 'bcdef'], ['a', 'b', 'c']), (['a'] * 5, ['b'] * 10))
+
+    yield Case(Annotated[str, at.Len(3, 5)], ('123', '12345'), ('', '1', '12', '123456', 'x' * 10))
+    yield Case(Annotated[str, at.Len(3, 3)], ('123',), ('12', '1234'))
+
+    yield Case(Annotated[dict[int, int], at.Len(2, 3)], [{1: 1, 2: 2}], [{}, {1: 1}, {1: 1, 2: 2, 3: 3, 4: 4}])
+    yield Case(Annotated[set[int], at.Len(2, 3)], ({1, 2}, {1, 2, 3}), (set(), {1}, {1, 2, 3, 4}))
+    yield Case(Annotated[tuple[int, ...], at.Len(2, 3)], ((1, 2), (1, 2, 3)), ((), (1,), (1, 2, 3, 4)))
+
+    # Timezone
+
+    yield Case(
+        Annotated[datetime, at.Timezone(None)], [datetime(2000, 1, 1)], [datetime(2000, 1, 1, tzinfo=timezone.utc)]
+    )
+    yield Case(
+        Annotated[datetime, at.Timezone(...)], [datetime(2000, 1, 1, tzinfo=timezone.utc)], [datetime(2000, 1, 1)]
+    )
+    yield Case(
+        Annotated[datetime, at.Timezone(timezone.utc)],
+        [datetime(2000, 1, 1, tzinfo=timezone.utc)],
+        [datetime(2000, 1, 1), datetime(2000, 1, 1, tzinfo=timezone(timedelta(hours=6)))],
+    )
+    yield Case(
+        Annotated[datetime, at.Timezone('Europe/London')],
+        [datetime(2000, 1, 1, tzinfo=timezone(timedelta(0), name='Europe/London'))],
+        [datetime(2000, 1, 1), datetime(2000, 1, 1, tzinfo=timezone(timedelta(hours=6)))],
+    )
+
+    # Quantity
+
+    yield Case(Annotated[float, at.Unit(unit='m')], (5, 4.2), ('5m', '4.2m'))
+
+    # predicate types
+
+    yield Case(at.LowerCase[str], ['abc', 'foobar'], ['', 'A', 'Boom'])
+    yield Case(at.UpperCase[str], ['ABC', 'DEFO'], ['', 'a', 'abc', 'AbC'])
+    yield Case(at.IsDigit[str], ['123'], ['', 'ab', 'a1b2'])
+    yield Case(at.IsAscii[str], ['123', 'foo bar'], ['£100', '😊', 'whatever 👀'])
+
+    yield Case(Annotated[int, at.Predicate(lambda x: x % 2 == 0)], [0, 2, 4], [1, 3, 5])
+
+    yield Case(at.IsFinite[float], [1.23], [math.nan, math.inf, -math.inf])
+    yield Case(at.IsNotFinite[float], [math.nan, math.inf], [1.23])
+    yield Case(at.IsNan[float], [math.nan], [1.23, math.inf])
+    yield Case(at.IsNotNan[float], [1.23, math.inf], [math.nan])
+    yield Case(at.IsInfinite[float], [math.inf], [math.nan, 1.23])
+    yield Case(at.IsNotInfinite[float], [math.nan, 1.23], [math.inf])
+
+    # check stacked predicates
+    yield Case(at.IsInfinite[Annotated[float, at.Predicate(lambda x: x > 0)]], [math.inf], [-math.inf, 1.23, math.nan])
+
+    # doc
+    yield Case(Annotated[int, at.doc("A number")], [1, 2], [])
+
+    # custom GroupedMetadata
+    class MyCustomGroupedMetadata(at.GroupedMetadata):
+        def __iter__(self) -> Iterator[at.Predicate]:
+            yield at.Predicate(lambda x: float(x).is_integer())
+
+    yield Case(Annotated[float, MyCustomGroupedMetadata()], [0, 2.0], [0.01, 1.5])

venv/Lib/site-packages/anyio-4.14.2.dist-info/INSTALLER

@@ -0,0 +1 @@
+pip

venv/Lib/site-packages/anyio-4.14.2.dist-info/METADATA

@@ -0,0 +1,107 @@
+Metadata-Version: 2.4
+Name: anyio
+Version: 4.14.2
+Summary: High-level concurrency and networking framework on top of asyncio or Trio
+Author-email: Alex Grönholm <alex.gronholm@nextday.fi>
+License-Expression: MIT
+Project-URL: Documentation, https://anyio.readthedocs.io/en/latest/
+Project-URL: Changelog, https://anyio.readthedocs.io/en/stable/versionhistory.html
+Project-URL: Source code, https://github.com/agronholm/anyio
+Project-URL: Issue tracker, https://github.com/agronholm/anyio/issues
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Framework :: AnyIO
+Classifier: Typing :: Typed
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
+Requires-Python: >=3.10
+Description-Content-Type: text/x-rst
+License-File: LICENSE
+Requires-Dist: exceptiongroup>=1.0.2; python_version < "3.11"
+Requires-Dist: idna>=2.8
+Requires-Dist: typing_extensions>=4.5; python_version < "3.13"
+Provides-Extra: trio
+Requires-Dist: trio>=0.32.0; extra == "trio"
+Dynamic: license-file
+
+.. image:: https://github.com/agronholm/anyio/actions/workflows/test.yml/badge.svg
+  :target: https://github.com/agronholm/anyio/actions/workflows/test.yml
+  :alt: Build Status
+.. image:: https://coveralls.io/repos/github/agronholm/anyio/badge.svg?branch=master
+  :target: https://coveralls.io/github/agronholm/anyio?branch=master
+  :alt: Code Coverage
+.. image:: https://readthedocs.org/projects/anyio/badge/?version=latest
+  :target: https://anyio.readthedocs.io/en/latest/?badge=latest
+  :alt: Documentation
+.. image:: https://badges.gitter.im/gitterHQ/gitter.svg
+  :target: https://gitter.im/python-trio/AnyIO
+  :alt: Gitter chat
+.. image:: https://tidelift.com/badges/package/pypi/anyio
+  :target: https://tidelift.com/subscription/pkg/pypi-anyio
+  :alt: Tidelift
+
+AnyIO is an asynchronous networking and concurrency library that works on top of either asyncio_ or
+Trio_. It implements Trio-like `structured concurrency`_ (SC) on top of asyncio and works in harmony
+with the native SC of Trio itself.
+
+Applications and libraries written against AnyIO's API will run unmodified on either asyncio_ or
+Trio_. AnyIO can also be adopted into a library or application incrementally – bit by bit, no full
+refactoring necessary. It will blend in with the native libraries of your chosen backend.
+
+To find out why you might want to use AnyIO's APIs instead of asyncio's, you can read about it
+`here <https://anyio.readthedocs.io/en/stable/why.html>`_.
+
+Documentation
+-------------
+
+View full documentation at: https://anyio.readthedocs.io/
+
+Features
+--------
+
+AnyIO offers the following functionality:
+
+* Task groups (nurseries_ in trio terminology)
+* High-level networking (TCP, UDP and UNIX sockets)
+
+  * `Happy eyeballs`_ algorithm for TCP connections (more robust than that of asyncio on Python
+    3.8)
+  * async/await style UDP sockets (unlike asyncio where you still have to use Transports and
+    Protocols)
+
+* A versatile API for byte streams and object streams
+* Inter-task synchronization and communication (locks, conditions, events, semaphores, object
+  streams)
+* Worker threads
+* Subprocesses
+* Subinterpreter support for code parallelization (on Python 3.13 and later)
+* Asynchronous file I/O (using worker threads)
+* Signal handling
+* Asynchronous versions of the functools_ and itertools_ modules
+
+AnyIO also comes with its own pytest_ plugin which also supports asynchronous fixtures.
+It even works with the popular Hypothesis_ library.
+
+.. _asyncio: https://docs.python.org/3/library/asyncio.html
+.. _Trio: https://github.com/python-trio/trio
+.. _structured concurrency: https://en.wikipedia.org/wiki/Structured_concurrency
+.. _nurseries: https://trio.readthedocs.io/en/stable/reference-core.html#nurseries-and-spawning
+.. _Happy eyeballs: https://en.wikipedia.org/wiki/Happy_Eyeballs
+.. _pytest: https://docs.pytest.org/en/latest/
+.. _functools: https://docs.python.org/3/library/functools.html
+.. _itertools: https://docs.python.org/3/library/itertools.html
+.. _Hypothesis: https://hypothesis.works/
+
+Security contact information
+----------------------------
+
+To report a security vulnerability, please use the `Tidelift security contact`_.
+Tidelift will coordinate the fix and disclosure.
+
+.. _Tidelift security contact: https://tidelift.com/security

venv/Lib/site-packages/anyio-4.14.2.dist-info/RECORD

@@ -0,0 +1,96 @@
+anyio-4.14.2.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+anyio-4.14.2.dist-info/METADATA,sha256=xeb8Tf2DMxmROyh756MNmTXpIIx--RdjBiGFWqrE1Bk,4645
+anyio-4.14.2.dist-info/RECORD,,
+anyio-4.14.2.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+anyio-4.14.2.dist-info/entry_points.txt,sha256=_d6Yu6uiaZmNe0CydowirE9Cmg7zUL2g08tQpoS3Qvc,39
+anyio-4.14.2.dist-info/licenses/LICENSE,sha256=U2GsncWPLvX9LpsJxoKXwX8ElQkJu8gCO9uC6s8iwrA,1081
+anyio-4.14.2.dist-info/scm_file_list.json,sha256=wDSXGv8Ehn5ZW5BhB-RlaAc16zY_OfO27qrlMfMMZy8,3654
+anyio-4.14.2.dist-info/scm_version.json,sha256=KgaUx31SyaqGFQFKpG3FO9kCk-ygOKS7Uf0yk56OzaY,161
+anyio-4.14.2.dist-info/top_level.txt,sha256=QglSMiWX8_5dpoVAEIHdEYzvqFMdSYWmCj6tYw2ITkQ,6
+anyio/__init__.py,sha256=HitUIfzvAojSeaHVmJ9rFn8k_yI63G6s_jUL2QChf4U,6405
+anyio/__pycache__/__init__.cpython-314.pyc,,
+anyio/__pycache__/from_thread.cpython-314.pyc,,
+anyio/__pycache__/functools.cpython-314.pyc,,
+anyio/__pycache__/itertools.cpython-314.pyc,,
+anyio/__pycache__/lowlevel.cpython-314.pyc,,
+anyio/__pycache__/pytest_plugin.cpython-314.pyc,,
+anyio/__pycache__/to_interpreter.cpython-314.pyc,,
+anyio/__pycache__/to_process.cpython-314.pyc,,
+anyio/__pycache__/to_thread.cpython-314.pyc,,
+anyio/_backends/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+anyio/_backends/__pycache__/__init__.cpython-314.pyc,,
+anyio/_backends/__pycache__/_asyncio.cpython-314.pyc,,
+anyio/_backends/__pycache__/_trio.cpython-314.pyc,,
+anyio/_backends/_asyncio.py,sha256=eK0j8PI0O7y3bX8cUBsafoWP8wsXR-szP6ciyP4Mkkk,104400
+anyio/_backends/_trio.py,sha256=hoTXL8zI81v4UE-YT_cr2fzh_zY1mKdmZD3oQHmeR0E,45583
+anyio/_core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+anyio/_core/__pycache__/__init__.cpython-314.pyc,,
+anyio/_core/__pycache__/_asyncio_selector_thread.cpython-314.pyc,,
+anyio/_core/__pycache__/_contextmanagers.cpython-314.pyc,,
+anyio/_core/__pycache__/_eventloop.cpython-314.pyc,,
+anyio/_core/__pycache__/_exceptions.cpython-314.pyc,,
+anyio/_core/__pycache__/_fileio.cpython-314.pyc,,
+anyio/_core/__pycache__/_resources.cpython-314.pyc,,
+anyio/_core/__pycache__/_signals.cpython-314.pyc,,
+anyio/_core/__pycache__/_sockets.cpython-314.pyc,,
+anyio/_core/__pycache__/_streams.cpython-314.pyc,,
+anyio/_core/__pycache__/_subprocesses.cpython-314.pyc,,
+anyio/_core/__pycache__/_synchronization.cpython-314.pyc,,
+anyio/_core/__pycache__/_tasks.cpython-314.pyc,,
+anyio/_core/__pycache__/_tempfile.cpython-314.pyc,,
+anyio/_core/__pycache__/_testing.cpython-314.pyc,,
+anyio/_core/__pycache__/_typedattr.cpython-314.pyc,,
+anyio/_core/_asyncio_selector_thread.py,sha256=2PdxFM3cs02Kp6BSppbvmRT7q7asreTW5FgBxEsflBo,5626
+anyio/_core/_contextmanagers.py,sha256=YInBCabiEeS-UaP_Jdxa1CaFC71ETPW8HZTHIM8Rsc8,7215
+anyio/_core/_eventloop.py,sha256=ByZUeJD9alMfcyTseRo5IzTO0IltEul_Gyq9iqSjqDk,6658
+anyio/_core/_exceptions.py,sha256=OfzLO4Z3Hog1TnipbIn72YNtkoYxS4lHW9MqKDeGc88,4936
+anyio/_core/_fileio.py,sha256=hHfyV0bXDL-R2ZNnInwse3nmTAd36AIz1cBxgmAwzAQ,31358
+anyio/_core/_resources.py,sha256=NbmU5O5UX3xEyACnkmYX28Fmwdl-f-ny0tHym26e0w0,435
+anyio/_core/_signals.py,sha256=mjTBB2hTKNPRlU0IhnijeQedpWOGERDiMjSlJQsFrug,1016
+anyio/_core/_sockets.py,sha256=HtjiSH-yzehlqh_LpD3PGIafDuUCwd8gueUuk5MFeNk,35288
+anyio/_core/_streams.py,sha256=FczFwIgDpnkK0bODWJXMpsUJYdvAD04kaUaGzJU8DK0,1806
+anyio/_core/_subprocesses.py,sha256=M2GCc4NKXCbB_GtEskJgndiM2b0VS0NK_ohmFxri7O8,7923
+anyio/_core/_synchronization.py,sha256=kgPk88-eVOmY-pDNs-ReRbcEelY1a7YczuVBPsZwc8A,21591
+anyio/_core/_tasks.py,sha256=y99vRi-AFzEv6kyvIwqrzuskE2NMiNItWnuWGk7eOr4,13126
+anyio/_core/_tempfile.py,sha256=jE2w59FRF3yRo4vjkjfZF2YcqsBZvc66VWRwrJGDYGk,19624
+anyio/_core/_testing.py,sha256=u7MPqGXwpTxqI7hclSdNA30z2GH1Nw258uwKvy_RfBg,2340
+anyio/_core/_typedattr.py,sha256=P4ozZikn3-DbpoYcvyghS_FOYAgbmUxeoU8-L_07pZM,2508
+anyio/abc/__init__.py,sha256=6mWhcl_pGXhrgZVHP_TCfMvIXIOp9mroEFM90fYCU_U,2869
+anyio/abc/__pycache__/__init__.cpython-314.pyc,,
+anyio/abc/__pycache__/_eventloop.cpython-314.pyc,,
+anyio/abc/__pycache__/_resources.cpython-314.pyc,,
+anyio/abc/__pycache__/_sockets.cpython-314.pyc,,
+anyio/abc/__pycache__/_streams.cpython-314.pyc,,
+anyio/abc/__pycache__/_subprocesses.cpython-314.pyc,,
+anyio/abc/__pycache__/_tasks.cpython-314.pyc,,
+anyio/abc/__pycache__/_testing.cpython-314.pyc,,
+anyio/abc/_eventloop.py,sha256=OqWYSEj0TmwL_xniCJt3_jHFWsuMk9THk8tCTGsKapI,10681
+anyio/abc/_resources.py,sha256=DrYvkNN1hH6Uvv5_5uKySvDsnknGVDe8FCKfko0VtN8,783
+anyio/abc/_sockets.py,sha256=OmVDrfemVvF9c5K1tpBgQyV6fn5v0XyCExLAqBOGz9o,13124
+anyio/abc/_streams.py,sha256=rnSwRy-6y80TPQtIXit5LjMMiU1CCWS1oMNsmJQHRTg,7582
+anyio/abc/_subprocesses.py,sha256=cumAPJTktOQtw63IqG0lDpyZqu_l1EElvQHMiwJgL08,2067
+anyio/abc/_tasks.py,sha256=m-FtE4phxeNIELSG7A3H7VUz3jA2Ib5J2JIew8-PS6o,6642
+anyio/abc/_testing.py,sha256=9YYM2AXsYFvf4PLjUEr6yRxDiUeB5QbY_gOg0X_C6lY,2034
+anyio/from_thread.py,sha256=JYsbaCaIB_Iit6kNhtXSteJGt4PcQ7ncq0nIpcelIrg,19265
+anyio/functools.py,sha256=T4JS8IXq-x1S0Lbo2owF8l9fza2KypO147QLeyz4cjs,11797
+anyio/itertools.py,sha256=QV-9mnRCr2yBph8g01QFvN-bQ_Yle-8Sl13YSydBlMI,16168
+anyio/lowlevel.py,sha256=-59484Z6K5jF7XJJhHxYHIKnvFH_uAeMhl9a_AfaSHI,6280
+anyio/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+anyio/pytest_plugin.py,sha256=paMpI_VMNQf2bir0LfvgMpXSiYJoHDzWdKUVTyoHmvQ,13609
+anyio/streams/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+anyio/streams/__pycache__/__init__.cpython-314.pyc,,
+anyio/streams/__pycache__/buffered.cpython-314.pyc,,
+anyio/streams/__pycache__/file.cpython-314.pyc,,
+anyio/streams/__pycache__/memory.cpython-314.pyc,,
+anyio/streams/__pycache__/stapled.cpython-314.pyc,,
+anyio/streams/__pycache__/text.cpython-314.pyc,,
+anyio/streams/__pycache__/tls.cpython-314.pyc,,
+anyio/streams/buffered.py,sha256=u7hCD8SNrYHcutG6K5wEiy1F88-pizgjvEFM22Kq2Cw,6746
+anyio/streams/file.py,sha256=6jujI2m-QJITqqKFamrupX_DNsU7y2Fz3omLZxOLuY0,4524
+anyio/streams/memory.py,sha256=ZmKWCLpyItOCXmvCQT-L8IyJHNFaB-OVJbrn88CaMo0,10776
+anyio/streams/stapled.py,sha256=mDNF9Gj4deXfOuKSZmgkEG-QExYAKAGjYBHbrs-rJaQ,4486
+anyio/streams/text.py,sha256=BcVAGJw1VRvtIqnv-o0Rb0pwH7p8vwlvl21xHq522ag,5765
+anyio/streams/tls.py,sha256=Gvs--YOoFxcyn-hakXOiPM8H-aEp8nsU6k9rTrKqJA4,15801
+anyio/to_interpreter.py,sha256=_mLngrMy97TMR6VbW4Y6YzDUk9ZuPcQMPlkuyRh3C9k,7100
+anyio/to_process.py,sha256=jHw7v6XHBNIfYa6DqnqKY0gsRo8ScOCh8fo19fqFvjU,9848
+anyio/to_thread.py,sha256=bYszW0lCDfTmLnXbAYic05HEe_Di_0UWKabgL2vU0T0,2750

venv/Lib/site-packages/anyio-4.14.2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

venv/Lib/site-packages/anyio-4.14.2.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[pytest11]
+anyio = anyio.pytest_plugin

venv/Lib/site-packages/anyio-4.14.2.dist-info/licenses/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Alex Grönholm
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

venv/Lib/site-packages/anyio-4.14.2.dist-info/scm_file_list.json

@@ -0,0 +1,119 @@
+{
+  "files": [
+    ".pre-commit-config.yaml",
+    "LICENSE",
+    "pyproject.toml",
+    "AGENTS.md",
+    "README.rst",
+    "CLAUDE.md",
+    ".readthedocs.yml",
+    ".gitignore",
+    "docs/tempfile.rst",
+    "docs/signals.rst",
+    "docs/synchronization.rst",
+    "docs/contextmanagers.rst",
+    "docs/testing.rst",
+    "docs/networking.rst",
+    "docs/contributing.rst",
+    "docs/index.rst",
+    "docs/versionhistory.rst",
+    "docs/threads.rst",
+    "docs/api.rst",
+    "docs/typedattrs.rst",
+    "docs/basics.rst",
+    "docs/fileio.rst",
+    "docs/cancellation.rst",
+    "docs/support.rst",
+    "docs/streams.rst",
+    "docs/why.rst",
+    "docs/tasks.rst",
+    "docs/migration.rst",
+    "docs/conf.py",
+    "docs/subprocesses.rst",
+    "docs/faq.rst",
+    "docs/subinterpreters.rst",
+    "src/anyio/functools.py",
+    "src/anyio/py.typed",
+    "src/anyio/__init__.py",
+    "src/anyio/pytest_plugin.py",
+    "src/anyio/itertools.py",
+    "src/anyio/to_interpreter.py",
+    "src/anyio/from_thread.py",
+    "src/anyio/to_process.py",
+    "src/anyio/to_thread.py",
+    "src/anyio/lowlevel.py",
+    "src/anyio/_backends/_trio.py",
+    "src/anyio/_backends/__init__.py",
+    "src/anyio/_backends/_asyncio.py",
+    "src/anyio/streams/memory.py",
+    "src/anyio/streams/__init__.py",
+    "src/anyio/streams/tls.py",
+    "src/anyio/streams/file.py",
+    "src/anyio/streams/text.py",
+    "src/anyio/streams/stapled.py",
+    "src/anyio/streams/buffered.py",
+    "src/anyio/abc/_eventloop.py",
+    "src/anyio/abc/__init__.py",
+    "src/anyio/abc/_sockets.py",
+    "src/anyio/abc/_tasks.py",
+    "src/anyio/abc/_subprocesses.py",
+    "src/anyio/abc/_resources.py",
+    "src/anyio/abc/_streams.py",
+    "src/anyio/abc/_testing.py",
+    "src/anyio/_core/_typedattr.py",
+    "src/anyio/_core/_eventloop.py",
+    "src/anyio/_core/__init__.py",
+    "src/anyio/_core/_tempfile.py",
+    "src/anyio/_core/_sockets.py",
+    "src/anyio/_core/_tasks.py",
+    "src/anyio/_core/_fileio.py",
+    "src/anyio/_core/_synchronization.py",
+    "src/anyio/_core/_subprocesses.py",
+    "src/anyio/_core/_resources.py",
+    "src/anyio/_core/_contextmanagers.py",
+    "src/anyio/_core/_exceptions.py",
+    "src/anyio/_core/_streams.py",
+    "src/anyio/_core/_signals.py",
+    "src/anyio/_core/_asyncio_selector_thread.py",
+    "src/anyio/_core/_testing.py",
+    "tests/test_itertools.py",
+    "tests/test_functools.py",
+    "tests/test_eventloop.py",
+    "tests/__init__.py",
+    "tests/test_to_thread.py",
+    "tests/test_from_thread.py",
+    "tests/test_lowlevel.py",
+    "tests/test_to_interpreter.py",
+    "tests/test_sockets.py",
+    "tests/test_typedattr.py",
+    "tests/test_to_process.py",
+    "tests/test_all_attributes.py",
+    "tests/test_synchronization.py",
+    "tests/test_debugging.py",
+    "tests/test_contextmanagers.py",
+    "tests/test_fileio.py",
+    "tests/conftest.py",
+    "tests/test_signals.py",
+    "tests/test_deprecations.py",
+    "tests/test_tempfile.py",
+    "tests/test_taskgroups.py",
+    "tests/test_pytest_plugin.py",
+    "tests/test_subprocesses.py",
+    "tests/streams/test_text.py",
+    "tests/streams/test_memory.py",
+    "tests/streams/__init__.py",
+    "tests/streams/test_file.py",
+    "tests/streams/test_stapled.py",
+    "tests/streams/test_tls.py",
+    "tests/streams/test_buffered.py",
+    ".github/pull_request_template.md",
+    ".github/dependabot.yml",
+    ".github/FUNDING.yml",
+    ".github/ISSUE_TEMPLATE/features_request.yaml",
+    ".github/ISSUE_TEMPLATE/bug_report.yaml",
+    ".github/ISSUE_TEMPLATE/config.yml",
+    ".github/workflows/test.yml",
+    ".github/workflows/test-downstream.yml",
+    ".github/workflows/publish.yml"
+  ]
+}

venv/Lib/site-packages/anyio-4.14.2.dist-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "4.14.2",
+  "distance": 0,
+  "node": "gc384f99687c64c59ed8a11c3a0f11a2d57daff71",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-07-12"
+}