tanml 0.1.6__py3-none-any.whl → 0.1.7__py3-none-any.whl

tanml/validate.py

@@ -1,209 +0,0 @@
-from __future__ import annotations
-import importlib
-from datetime import datetime
-from pathlib import Path
-from importlib.resources import files
-from typing import Optional, Dict, Any
-
-import joblib
-import pandas as pd
-import tzlocal
-from sklearn.model_selection import train_test_split
-
-from tanml.cli.arg_parser import parse_args
-from tanml.engine.segmentation_agent import handle_segmentation
-from tanml.engine.core_engine_agent import ValidationEngine
-from tanml.report.report_builder import ReportBuilder
-from tanml.utils.data_loader import load_dataframe
-from tanml.utils.model_loader import load_model
-from tanml.utils.yaml_loader import load_yaml_config
-
-
-load_yaml = load_yaml_config
-
-def _resolve_template_path(explicit: Optional[str] = None) -> Path:
-    """Return a Path to the DOCX report template.
-
-    Priority:
-    1.  If the caller supplied an absolute/relative path (`explicit`), use it.
-    2.  Fallback to the *packaged* template shipped inside
-        `tanml.report.templates`.
-    """
-    if explicit:
-        return Path(explicit).expanduser().resolve()
-
-    # packaged default
-    return files("tanml.report.templates").joinpath("report_template.docx")
-
-
-# ---------------------------------------------------------------------------
-# CLI path (Scenario A)
-# ---------------------------------------------------------------------------
-
-def validate_from_args() -> None:
-    args = parse_args()
-
-    # Read YAML rules if provided via --rules, else an empty dict
-    rule_cfg: Dict[str, Any] = load_yaml(args.rules) if args.rules else {}
-    explicit_feats = rule_cfg.get("model", {}).get("features", [])
-
-    # Optional feature override from CLI flag
-    if not explicit_feats and args.features:
-        explicit_feats = [f.strip() for f in args.features.split(",")]
-        print(f"✅ Using CLI feature override: {explicit_feats}")
-
-    # -------------------------------------------------------------------
-    # Segmentation scenarios (B / C) are handled by a dedicated agent
-    # -------------------------------------------------------------------
-    if "segment" in rule_cfg and ("runs" in rule_cfg["segment"] or "column" in rule_cfg["segment"]):
-        print("✅ Detected segmentation scenario (Scenario B or C).")
-        handle_segmentation(rule_cfg["segment"], rule_cfg, args, args.report_path)
-        return
-
-    # -------------------------------------------------------------------
-    # Scenario A (single model / dataset)
-    # -------------------------------------------------------------------
-    if not args.model:
-        raise ValueError("❌ No model path provided (use --model).")
-
-    model = load_model(args.model)
-    raw_df = load_dataframe(args.raw)
-    cleaned_df = load_dataframe(args.cleaned)
-
-    # Column sanity check
-    if explicit_feats:
-        missing = set(explicit_feats) - set(cleaned_df.columns)
-        if missing:
-            raise ValueError(f"❌ cleaned.csv missing columns: {missing}")
-
-    target = args.target
-    if target not in cleaned_df.columns:
-        raise ValueError(f"❌ Target column '{target}' not found in cleaned data.")
-
-    y = cleaned_df[target]
-    X = cleaned_df.drop(columns=[target])
-
-    # Feature‑name consistency with persisted model
-    if hasattr(model, "feature_names_in_"):
-        expected = list(model.feature_names_in_)
-        if expected != list(X.columns):
-            raise ValueError(
-                "❌ Feature mismatch\nExpected: "
-                f"{expected}\nGot:      {list(X.columns)}"
-            )
-        print("✅ Feature names match the model expectations.")
-
-    # Train/test split
-    test_size = rule_cfg.get("train_test_split", {}).get("test_size", 0.3)
-    X_train, X_test, y_train, y_test = train_test_split(
-        X, y, test_size=test_size, random_state=42
-    )
-
-    engine = ValidationEngine(model, X_train, X_test, y_train, y_test, rule_cfg, cleaned_df)
-    results = engine.run_all_checks()
-
-    # Meta‑info block for the report
-    now = datetime.now(tzlocal.get_localzone())
-    results.update(
-        {
-            "validation_date": now.strftime("%Y-%m-%d %H:%M:%S %Z (UTC%z)"),
-            "model_path": args.model,
-            "validated_by": "TanML Automated Validator",
-            "rules": rule_cfg.get("rules", {}),
-        }
-    )
-
-    # -------------------------------------------------------------------
-    # Report output location
-    # -------------------------------------------------------------------
-    output_path = Path(args.report_path).expanduser().resolve()
-    if output_path.exists() and output_path.is_dir():
-        raise ValueError(
-            f"'{output_path}' is a directory. Please provide a full .docx filename."
-        )
-    output_path.parent.mkdir(parents=True, exist_ok=True)
-
-    template_path = _resolve_template_path(rule_cfg.get("output", {}).get("template_path"))
-    ReportBuilder(results, template_path=template_path, output_path=output_path).build()
-    print(f"\n✅ Report saved to {output_path}")
-
-
-# ---------------------------------------------------------------------------
-# YAML‑driven path (CLI `tanml validate --rules <file>.yaml`)
-# ---------------------------------------------------------------------------
-
-def validate_from_yaml(rules_path: str | Path) -> None:
-    config = load_yaml_config(rules_path)
-
-    # Segmentation handling first
-    report_output_tpl = config.get("output", {}).get("report_path_template", "reports/{segment}")
-    if "segment" in config and "runs" in config["segment"]:
-        print("🔍 Detected segmentation setup in rules.yaml. Running segment‑wise validation.")
-        handle_segmentation(config["segment"], config, args=None, report_output=report_output_tpl)
-        return
-
-    # --------------------------
-    # Scenario A (single run)
-    # --------------------------
-    cleaned_df = pd.read_csv(config["paths"]["cleaned_data"])
-    print(f"✅ Loaded cleaned data from: {config['paths']['cleaned_data']}")
-    print("✅ No segmentation detected. Running single model validation.")
-
-    target = config["model"]["target"]
-    features = config["model"]["features"]
-    X = cleaned_df[features]
-    y = cleaned_df[target]
-
-    # Model loader / trainer
-    if config.get("model_source", {}).get("from_pickle", True):
-        model_path = config["paths"].get("model")
-        if not model_path:
-            raise ValueError("❌ 'paths.model' must be provided when using from_pickle = true")
-        model = joblib.load(model_path)
-        print(f"✅ Loaded model from: {model_path}")
-    else:
-        model_cfg = config["model_source"]
-        module = importlib.import_module(model_cfg["module"])
-        model_class = getattr(module, model_cfg["type"])
-        model = model_class(**model_cfg.get("hyperparameters", {}))
-        model.fit(X, y)
-        print(f"✅ Retrained model from: {model_cfg['module']}.{model_cfg['type']}")
-        # For SHAP etc.
-        if not hasattr(model, "feature_names_in_"):
-            model.feature_names_in_ = X.columns.to_numpy()
-
-    # Train/test split
-    test_size = config.get("train_test_split", {}).get("test_size", 0.3)
-    X_train, X_test, y_train, y_test = train_test_split(
-        X, y, test_size=test_size, random_state=42
-    )
-
-    ctx = {"expected_features": features}
-    engine = ValidationEngine(model, X_train, X_test, y_train, y_test, config, cleaned_df, ctx=ctx)
-    results = engine.run_all_checks()
-
-    # Meta block
-    now = datetime.now(tzlocal.get_localzone())
-    results.update(
-        {
-            "validation_date": now.strftime("%Y-%m-%d %H:%M:%S %Z (UTC%z)"),
-            "model_path": config["paths"].get("model", "retrained_from_yaml"),
-            "validated_by": "TanML Automated Validator",
-            "rules": config.get("rules", {}),
-        }
-    )
-
-    # Report output
-    report_path = Path(config.get("output", {}).get("report_path", "report.docx")).expanduser()
-    report_path.parent.mkdir(parents=True, exist_ok=True)
-
-    template_path = _resolve_template_path(config.get("output", {}).get("template_path"))
-    ReportBuilder(results, template_path=template_path, output_path=report_path).build()
-
-    print(f"📄 Report saved: {report_path}")
-    print("✅ All validations completed.")
-
-
-if __name__ == "__main__":
-    validate_from_args()
-

tanml-0.1.6.dist-info/METADATA

@@ -1,317 +0,0 @@
-Metadata-Version: 2.4
-Name: tanml
-Version: 0.1.6
-Summary: Automated validation toolkit for tabular ML models in finance and regulated domains.
-Author: Dolly Sah
-Author-email: Tanmay Sah <tradertanmay@gmail.com>
-License: MIT
-Project-URL: Homepage, https://github.com/tdlabs-ai/tanml
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: scikit-learn
-Requires-Dist: pandas
-Requires-Dist: matplotlib
-Requires-Dist: seaborn
-Requires-Dist: shap
-Requires-Dist: docxtpl
-Requires-Dist: python-docx
-Requires-Dist: docxcompose
-Requires-Dist: PyYAML
-Requires-Dist: scipy
-Requires-Dist: statsmodels
-Requires-Dist: joblib
-Requires-Dist: tzlocal
-Requires-Dist: tqdm
-Requires-Dist: imgkit
-Requires-Dist: xgboost
-Provides-Extra: dev
-Requires-Dist: pytest; extra == "dev"
-Requires-Dist: black; extra == "dev"
-Requires-Dist: isort; extra == "dev"
-Dynamic: license-file
-
-# TanML: Automated Model Validation Toolkit for Tabular Machine Learning  
-[![Cite this repo](https://img.shields.io/badge/Cite-this_repo-blue)](https://github.com/tdlabs-ai/tanml)
-
-TanML is a modular, automated model validation toolkit for tabular machine learning workflows. It supports end-to-end validation with just a YAML configuration and a single command, performing checks across data quality, robustness, explainability, and model performance.
-
-TanML generates structured Word (DOCX) reports suitable for internal model reviews, audit documentation, and stakeholder presentations. It is designed for general-purpose ML validation and works well in domains where interpretability, fairness, and reliability are critical.
-
-While TanML currently operates as a command-line toolkit, its architecture is designed to evolve into an intelligent validation agent—capable of integrating with AutoML pipelines, CI/CD workflows, and human-in-the-loop validation systems.
-
-## Key Features
-
-* One-command validation using CLI and YAML
-* Supports models developed in Python (scikit-learn, XGBoost), R, or SAS
-* Scenario-based flexibility:
-
-  * Scenario A: Single model and dataset
-  * Scenario B: One model per segment with separate datasets
-  * Scenario C: One model and dataset with an internal segmentation column
-* Comprehensive validation checks:
-
-  * Model performance (e.g., accuracy, AUC, KS)
-  * Data quality diagnostics
-  * Stress testing for input robustness
-  * SHAP-based explainability
-  * Segment-wise validation
-  * Logistic regression coefficient summaries (if applicable)
-  * VIF, correlation, and multicollinearity checks
-  * EDA summaries
-  * Rule-based threshold validation using YAML configuration
-* Professional report generation in Word (DOCX) format
-* Easily extensible architecture to add custom checks or outputs
-
-## Installation
-
-TanML can be installed directly from PyPI using pip:
-
-```bash
-pip install tanml
-```
-
-To upgrade to the latest version:
-
-```bash
-pip install --upgrade tanml
-```
-
-After installation, you can verify the CLI is working by running:
-
-```bash
-tanml --help
-```
-
-This will display the list of available commands and options.
-
-TanML supports Python 3.8 and above. It is recommended to use a virtual environment for clean dependency management:
-
-```bash
-python3 -m venv .venv
-source .venv/bin/activate  # On Windows: .venv\Scripts\activate
-```
-
-## Folder Structure
-
-A typical TanML project is organized as follows:
-
-```
-TanML/
-├── models/                # Trained model files (e.g., .pkl, .sas7bdat)
-├── data/
-│   ├── raw/               # Raw data files (optional)
-│   └── cleaned/           # Cleaned datasets for validation
-├── examples/
-│   ├── scenario_a/        # Example for single model and dataset
-│   ├── scenario_b/        # One model per segment
-│   └── scenario_c/        # Single model with segmentation column
-├── reports/
-│   ├── images/            # SHAP plots, cluster visualizations
-│   ├── clusters/          # Cluster summary CSVs
-│   └── *.docx             # Final validation reports
-├── tanml/                 # Core source code
-│   ├── cli/               # CLI logic
-│   ├── engine/            # Orchestration and segmentation logic
-│   ├── checks/            # Validation check classes
-│   ├── check_runners/     # Check runners linked to the engine
-│   ├── report/            # Report generation using docxtpl
-│   └── utils/             # Data/model loaders and helpers
-├── tests/                 # Unit tests (WIP or planned)
-├── setup.py               # Package installer for pip
-├── pyproject.toml         # Modern Python build metadata (PEP 518)
-├── MANIFEST.in            # Files to include when packaging
-└── README.md              # This documentation
-```
-
-## How to Use TanML
-
-To use TanML effectively, follow these three main steps. This process is designed to be simple and intuitive, even for users without a programming background.
-
-1. **Initialize the Configuration File:**
-   Start by generating a YAML configuration file that tells TanML how to run the validation. You do this using a command-line instruction where you select one of the three supported validation scenarios:
-
-   * Scenario A: For validating one model using a single dataset
-   * Scenario B: For validating multiple models, each with its own segment-specific dataset
-   * Scenario C: For validating a single model that needs to be run separately on different segments within one dataset
-
-   You can also choose where the generated YAML file should be saved. If you don’t provide a location, it will be saved in your current directory with a default name.
-
-2. **Fill in the Configuration File:**
-   Once the YAML file is created, you’ll open it and fill in the necessary details:
-
-   * Where your model file is located (e.g., a `.pkl` file for Python, or equivalent for SAS or R)
-   * Where your cleaned dataset is saved
-   * (Optional) Where your raw dataset is saved, if you want data quality comparisons
-   * Which input features your model expects, and what the target column is
-   * Where you want the final report to be saved (Word `.docx` format)
-
-   This YAML file acts like a blueprint—TanML reads it and follows the instructions you provide to run all relevant validation checks.
-
-3. **Run the Validation Process:**
-   After the YAML file is completed, you will run the validation process. This will trigger TanML to:
-
-   * Load your model and data
-   * Perform all configured validation checks (like performance, SHAP explainability, stress testing, etc.)
-   * Automatically generate a professional report with summaries, tables, and visuals
-
-You can use TanML either through simple command-line instructions or directly in Python by calling its functions. Both methods achieve the same results. The command-line approach is ideal for repeatable, scriptable workflows, while the Python interface is useful for advanced users who want to integrate TanML into larger systems or notebooks.
-
-TanML is controlled entirely through a YAML configuration file and a single CLI command. The configuration specifies the model, data, validation rules, and output paths.
-
-### Scenario A: Single Model, Single Dataset
-
-This is the simplest usage mode. You have one model file and one cleaned dataset.
-
-**rules.yaml**
-
-```yaml
-model:
-  features:
-    - age
-    - income
-    - debt_to_income
-    - credit_score
-    - employment_length
-  target: default_flag
-
-paths:
-  model: models/model.pkl
-  cleaned_data: data/cleaned/cleaned.csv
-  raw_data: data/raw/raw.csv
-
-output:
-  report_path: reports/validation_report.docx
-```
-
-**Run the validation:**
-
-```bash
-tanml validate --rules rules.yaml
-```
-
-This generates a `.docx` report along with SHAP plots and other artifacts.
-
-### Scenario B: One Model per Segment
-
-Use this if you have multiple segments, each with its own cleaned dataset and model.
-
-**rules.yaml**
-
-```yaml
-segment:
-  runs:
-    segment_A:
-      model: models/model_segment_A.pkl
-      cleaned: data/cleaned/segment_A.csv
-      raw: data/raw/segment_A.csv
-      output_report: reports/report_segment_A.docx
-
-    segment_B:
-      model: models/model_segment_B.pkl
-      cleaned: data/cleaned/segment_B.csv
-      raw: data/raw/segment_B.csv
-      output_report: reports/report_segment_B.docx
-
-model:
-  features:
-    - age
-    - income
-    - debt_to_income
-    - credit_score
-    - employment_length
-  target: default_flag
-```
-
-**Run the validation:**
-
-```bash
-tanml validate --rules rules.yaml
-```
-
-Each segment will be validated independently with its own output report.
-
-### Scenario C: One Model with Segmentation Column
-
-Use this if you have one dataset with a segmentation column (e.g., region, product type).
-
-**rules.yaml**
-
-```yaml
-segment:
-  column: segment_id  # This column will be used to split the data automatically
-
-model:
-  features:
-    - age
-    - income
-    - debt_to_income
-    - credit_score
-    - employment_length
-  target: default_flag
-
-paths:
-  model: models/credit_model.pkl
-  cleaned_data: data/cleaned/combined.csv
-  raw_data: data/raw/combined.csv
-
-output:
-  report_path: reports/report_{segment}.docx
-```
-
-**Run the validation:**
-
-```bash
-tanml validate --rules rules.yaml
-```
-
-This will automatically split the dataset by the `segment_id` column, apply the same model to each subset, and produce one report per segment.
-
-## Output Artifacts
-
-After a successful validation run, TanML generates a set of output files based on your configuration:
-
-- **Validation Report (.docx):**  
-  A professionally formatted Word document containing:
-  - A summary of all validation checks
-  - Tables for performance metrics, data quality, logistic regression coefficients, VIF, and more
-  - SHAP-based feature importance visualizations (if enabled)
-  - Segment-wise validation summaries (for Scenario B and C)
-
-- **SHAP Visualizations:**  
-  Summary bar plots and other SHAP outputs are saved in the `reports/images/` folder.
-
-- **Input Cluster Coverage Charts and CSVs:**  
-  If cluster coverage analysis is enabled, visual and tabular summaries are stored in:
-  - `reports/images/` (cluster bar plots)
-  - `reports/clusters/` (CSV summaries)
-
-- **Logs and Intermediate Results:**  
-  Optional debug or intermediate outputs (e.g., cleaned data snapshots or rule validation results) can be generated depending on configuration or verbosity level.
-
-By default, all outputs are saved to the paths you define in the YAML configuration. Each segment (in Scenario B or C) will generate its own report file if multiple runs are triggered.
-
-Extending TanML
-
-TanML is designed with modularity in mind. Advanced users and developers can easily extend its capabilities by adding new validation checks or modifying report components. Here's how extension works:
-
-Add a Custom Check:Create a new check class in the tanml/checks/ directory and implement the validation logic based on the BaseCheck interface.
-
-Create a Check Runner:Add a corresponding runner in tanml/check_runners/. This file controls how the check is executed and connected to the engine.
-
-Register the Check:Link your runner in the central registry inside the validation engine. The YAML config will trigger it automatically based on user-defined rules.
-
-This modular structure ensures that domain-specific validations (e.g., industry regulations, fairness audits) can be added without modifying core logic.
-
-## License and Citation
-
-TanML is open-source under the MIT License.  
-Copyright © 2025 Tanmay Sah and Dolly Sah.
-
-You are free to use, modify, and distribute this software with appropriate attribution.
-
-If you use TanML in your work or publication, please cite it as:
-
-> Sah, T., & Sah, D. (2025). *TanML: Automated Model Validation Toolkit for Tabular Machine Learning*. GitHub. https://github.com/tdlabs-ai/tanml
-
-📄 A machine-readable citation file (`CITATION.cff`) is included for use with citation tools and GitHub's “Cite this repository” button.

tanml-0.1.6.dist-info/RECORD

@@ -1,62 +0,0 @@
-tanml/__init__.py,sha256=5xvN_gb61nKeq5TER5dSfcArTP3DVasZGN_MQq5dNpA,23
-tanml/validate.py,sha256=GgLPaCHXk126hb-En_caQzDW0AViqh5QU0JBJP1cILo,8502
-tanml/check_runners/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tanml/check_runners/base_runner.py,sha256=jibUcl6a7SQH9EKnPFZhU1t9FY-Bu_nkPjRfjW2T5x0,210
-tanml/check_runners/cleaning_repro_runner.py,sha256=nr3HlA1rxy6qv3XqBgK1gf6euz6zRLdsTf4tB41Nk0k,921
-tanml/check_runners/correlation_runner.py,sha256=rhcOoZkbALZMGFax-wFMRCJ8JgmVa3k4uui4DSHdpfs,597
-tanml/check_runners/data_quality_runner.py,sha256=IdhWYOtDBPkAwT2Aa6SYSiI2gkLEhkBXHAQop5ZFg0I,883
-tanml/check_runners/eda_runner.py,sha256=Gr5ZmgOvUilej-rhinsL9KmsIQOMWjd6jdOYUQTJ4os,623
-tanml/check_runners/explainability_runner.py,sha256=okA6zfybTeDRiaNeoR8QyR00mqvyRX28wNylR_R-N_g,840
-tanml/check_runners/input_cluster_runner.py,sha256=0O8JJq3HOvNd3_nrZY8FevVYimI_Nl2Iftyyx56LVzc,1251
-tanml/check_runners/logistic_stats_runner.py,sha256=nst-kW-uDLbdXYG9bBzhdDAHd2MX4TnNv94EF9-Jigg,1181
-tanml/check_runners/model_meta_runner.py,sha256=hOIEp6k98o0FwYjgmi_53Ni7H14jerKdf46wpxVkAkk,799
-tanml/check_runners/performance_runner.py,sha256=Dqhm1kNwKdbMc_GBr-yivQGX3nxa__fW9XmXZnnSvXM,1150
-tanml/check_runners/raw_data_runner.py,sha256=XhroQoyiJb2B8URO1pMgI6H0RuwVqKzzPJGjzu5NbZE,1430
-tanml/check_runners/rule_engine_runner.py,sha256=xgij_9S8kUSESgXeWGN7FnOD0hNmd3GAregxuD_x9nI,286
-tanml/check_runners/stress_test_runner.py,sha256=xw3Q8Da_U91MQE9sixUn7RJu-y4IUu2lUQYyGzymOgc,1109
-tanml/check_runners/vif_runner.py,sha256=0CeR5nl_JRVRoSProuJitbzRxw7AFNXt0FtnhBe2aP0,1893
-tanml/checks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tanml/checks/base.py,sha256=g1GLXHWkE848bDKb4zXLHRqfgucVWFa-n6ZDT5vzs2I,570
-tanml/checks/cleaning_repro.py,sha256=LtPEkikjTY0NMsv1FZ8tOPUkaqF3yK_-DQdLCltMsIA,1795
-tanml/checks/correlation.py,sha256=WT83wAclH73ud8JzA5HRe8VfWd1y3dfPR7VPkDutMqw,2135
-tanml/checks/data_quality.py,sha256=bNrM469c_G-TxU-6ne2UYv5gwoUoyrab4lYbI16l7VU,981
-tanml/checks/eda.py,sha256=7fOIBhCg0oiK4SL22WcKHK8vL3s-YwypiAnZDwoq3lo,2515
-tanml/checks/input_cluster.py,sha256=93RvE-vd_elt4xqnkCkHmHH6NWPOtJF7ylb5mPTsagA,3990
-tanml/checks/logit_stats.py,sha256=0BuuKYG8L-A0CPpq6hiL-uSporUnzyuElSgdYmvUeFo,1850
-tanml/checks/model_contents.py,sha256=jcS4GrUoaQVUBf9pFwvtv9KKvDO5vZroiPz8mOmyAGo,1263
-tanml/checks/model_meta.py,sha256=x2RnT3kUWY4ERWfM9cItpaIJX8Fca9IQByR9zPN2V20,1881
-tanml/checks/performance.py,sha256=vQ_FeIcr3ASDhVd97y2JKMEMfJUrfCRnUBZh1ZI6rCs,3400
-tanml/checks/raw_data.py,sha256=si67YqKVd6v6dzTeUK6ZLD3KSzRpO6ohODPNv7L3zio,1785
-tanml/checks/rule_engine.py,sha256=bqGd0-2MlSPGGUFPyMxgHiwVTvw1Iu7NFqUzl_-0iIg,1694
-tanml/checks/stress_test.py,sha256=ILpgbi-qWvHwbX7aJL-3Xsj-gHxWyaw64tGK7fLiiCo,2438
-tanml/checks/vif.py,sha256=0tghDaiG8z4frgP5OHj3ctgsH4Mak1N7Docu6OcG8JA,1902
-tanml/checks/explainability/shap_check.py,sha256=LIRcFvsYJl37I5Rr6WoNDEIUGL3mhtj4CcqBfj5XvZA,2091
-tanml/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tanml/cli/arg_parser.py,sha256=m13PWV2DmO3Hl-sGOt-VCqJ3cFocrLhWQT4MaDmjl7E,1674
-tanml/cli/init_cmd.py,sha256=Coj681Zp3CAsTL-wXGM8QVop7me-vV3l4OBA74XjETQ,308
-tanml/cli/main.py,sha256=Z288eLioZdT0k2ApLP-0m0xnSHI446mW823bS3YnQeI,1195
-tanml/cli/validate_cmd.py,sha256=Civ6ELN7jO65TUeXsI9TX41iwoelqYOtWvHsX8CJn3g,218
-tanml/config_templates/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tanml/config_templates/rules_multiple_models_datasets.yaml,sha256=_swwZsKV5TMGYy2IxHU_d381rqcGU12tZg59yl8NKuk,4872
-tanml/config_templates/rules_one_dataset_segment_column.yaml,sha256=jmUA5TGuSDt7o6WRTNFA9Nv4ObOnDywBgI4jNHYzKpI,4416
-tanml/config_templates/rules_one_model_one_dataset.yaml,sha256=BHggGZnMeqWR4aKisgD8ghH5fZORCRVVD_KP6GpoE-g,4452
-tanml/engine/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tanml/engine/check_agent_registry.py,sha256=UzJZhnAkMh4s-nYUMFPSspZZav8AHwmLuYveVIdlUcQ,2120
-tanml/engine/core_engine_agent.py,sha256=fvWZa2XjadcKhhvQiGuOlb5x3KQFwFyH6bjJfqz91wk,3653
-tanml/engine/segmentation_agent.py,sha256=ETCGvQ6mUf4qmtfdCrQlO9nGqpIxApfod3tObdDHlTY,4904
-tanml/engine/validation_agent.py,sha256=5js9NDIx7mItXA7SYWr85Oe5wwmDyePAqkB6i49imKk,3393
-tanml/report/report_builder.py,sha256=SIXI6pFDXLRa3DlrA4uM6s-5Do33iTj85Yk6biX4W9A,8538
-tanml/report/templates/report_template.docx,sha256=Pq5QNSclws5PNaGntul4Y4JwWf08MjNBno-UN__XWYY,27170
-tanml/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tanml/utils/data_loader.py,sha256=pYOcp8bmA9mq9FBxk_0-O5z8GtnxR24ooDCRWUYv83s,545
-tanml/utils/model_loader.py,sha256=bcYyaLfEkgpfCw_BCUqRifZxckMRnR-9O32F_EnCYWg,1121
-tanml/utils/r_loader.py,sha256=88k7deZWvO68zYGK8G8rFHfc_VoVK2h8ce55pD8lw3U,964
-tanml/utils/sas_loader.py,sha256=8-hz2jlS71hbiacP99mnG7Ip5zV0f09htPl1-h34Qvw,1673
-tanml/utils/yaml_generator.py,sha256=sBumacoUAZFoxG9Enr7mljgCSzp9RAbszsVYlDATz4c,1130
-tanml/utils/yaml_loader.py,sha256=QlrwEm685wDiQjkR-BYQ45HIyuQS6_H6ajadAp1nsrg,110
-tanml-0.1.6.dist-info/licenses/LICENSE,sha256=e6xQyG7SdWiD4cLlj7rFdMrjG6H7ABglGOrooZxWLKQ,1102
-tanml-0.1.6.dist-info/METADATA,sha256=655Z4HIVXKeMgjfqESMcv9XSngupFKKg-FrRFk77Iw4,11973
-tanml-0.1.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-tanml-0.1.6.dist-info/entry_points.txt,sha256=WUM_y0uRIL7iXPcxK69Bn5mKZXnDshWDbLyohjND1IE,46
-tanml-0.1.6.dist-info/top_level.txt,sha256=81dIhCm6opwY6E7Pb9G1kdIVmYrUkXX4PaYhQ873gIE,6
-tanml-0.1.6.dist-info/RECORD,,