regsim-in 0.1.0__py3-none-any.whl

regsim/cli.py

@@ -0,0 +1,107 @@
+# regsim/cli.py
+
+import argparse
+import json
+import os
+import sys
+
+from importlib import metadata
+
+from regsim.commands.simulate import run_simulation
+from regsim.core.simulation import load_json, load_rules, simulate
+from regsim.engine import InvalidPayloadError
+from regsim.parser import extract_from_file
+
+
+def get_version():
+    return metadata.version("regsim-in")
+
+
+def print_error(message: str, exit_code: int = 1) -> None:
+    print(json.dumps({
+        "status": "ERROR",
+        "message": message,
+    }))
+    sys.exit(exit_code)
+
+
+def main():
+    parser = argparse.ArgumentParser(prog="regsim-in")
+    parser.add_argument(
+        "--version",
+        action="store_true",
+        help="Print RegSim-IN version",
+    )
+
+    subparsers = parser.add_subparsers(dest="command", required=False)
+
+    simulate_parser = subparsers.add_parser("simulate", help="Run regulatory simulation")
+    simulate_parser.add_argument("--rules", required=True)
+    simulate_parser.add_argument("--input", required=True)
+    simulate_parser.add_argument(
+        "--snapshot-date",
+        help="Regulatory snapshot date (YYYY-MM-DD)",
+        required=False,
+    )
+
+    args = parser.parse_args()
+
+    if args.version:
+        print(get_version())
+        sys.exit(0)
+
+    if not args.command:
+        parser.print_help()
+        sys.exit(2)
+
+    if args.command == "simulate":
+        try:
+            rules = load_rules(args.rules)
+
+            if os.path.isdir(args.input):
+                all_results = []
+                extraction_errors = []
+
+                for root, dirs, files in os.walk(args.input):
+                    dirs.sort()
+                    for filename in sorted(files):
+                        if not filename.endswith(".py"):
+                            continue
+                        file_path = os.path.join(root, filename)
+                        extraction = extract_from_file(file_path)
+                        if extraction.errors:
+                            extraction_errors.extend(extraction.errors)
+                            continue
+                        for payload in extraction.payloads:
+                            all_results.append(
+                                simulate(rules, payload, snapshot_date=args.snapshot_date)
+                            )
+
+                if extraction_errors:
+                    print_error("; ".join(extraction_errors), exit_code=2)
+
+                print(json.dumps(all_results, indent=2))
+                sys.exit(1 if any(r["status"] == "FAIL" for r in all_results) else 0)
+
+            if args.input.endswith(".py"):
+                extraction = extract_from_file(args.input)
+
+                if extraction.errors:
+                    print_error("; ".join(extraction.errors), exit_code=2)
+
+                all_results = []
+                for payload in extraction.payloads:
+                    all_results.append(
+                        simulate(rules, payload, snapshot_date=args.snapshot_date)
+                    )
+
+                print(json.dumps(all_results, indent=2))
+                sys.exit(1 if any(r["status"] == "FAIL" for r in all_results) else 0)
+
+            payload = load_json(args.input)
+            result = simulate(rules, payload, snapshot_date=args.snapshot_date)
+            print(json.dumps(result, indent=2))
+        except InvalidPayloadError as e:
+            print_error(str(e), exit_code=1)
+        except Exception as e:
+            print_error(str(e), exit_code=1)

regsim/commands/simulate.py

@@ -0,0 +1,5 @@
+# regsim/commands/simulate.py
+
+from regsim.core.simulation import run_simulation
+
+__all__ = ["run_simulation"]

regsim/core/__init__.py

@@ -0,0 +1,3 @@
+from regsim.core.simulation import run_simulation
+
+__all__ = ["run_simulation"]

regsim/core/evaluator.py

@@ -0,0 +1,65 @@
+from regsim.core.fields import get_field
+from regsim.core.validators import is_invalid_gstin
+
+
+def evaluate_condition(condition, payload):
+    if "field" not in condition:
+        for raw_key, expected in condition.items():
+            if raw_key.endswith("_gt"):
+                field = raw_key[:-3]
+                operator = ">"
+            elif raw_key.endswith("_gte"):
+                field = raw_key[:-4]
+                operator = ">="
+            elif raw_key.endswith("_eq"):
+                field = raw_key[:-3]
+                operator = "=="
+            else:
+                field = raw_key
+                operator = "=="
+
+            found, field_value = get_field(payload, field)
+            if not found:
+                return False
+
+            try:
+                if operator == ">":
+                    if not field_value > expected:
+                        return False
+                elif operator == ">=":
+                    if not field_value >= expected:
+                        return False
+                elif operator == "==":
+                    if not field_value == expected:
+                        return False
+                else:
+                    raise ValueError(f"Unsupported operator: {operator}")
+            except TypeError:
+                return False
+
+        return True
+
+    found, field_value = get_field(payload, condition["field"])
+    operator = condition["operator"]
+    expected = condition["value"]
+
+    if operator == "missing":
+        return not found
+
+    if operator == "invalid_gstin":
+        return not found or is_invalid_gstin(field_value)
+
+    if not found:
+        return False
+
+    try:
+        if operator == ">":
+            return field_value > expected
+        if operator == ">=":
+            return field_value >= expected
+        if operator == "==":
+            return field_value == expected
+    except TypeError:
+        return False
+
+    raise ValueError(f"Unsupported operator: {operator}")

regsim/core/fields.py

@@ -0,0 +1,29 @@
+from typing import Any
+
+
+def get_field(payload: Any, field_path: str):
+    if field_path is None or field_path == "":
+        return True, payload
+
+    current = payload
+    for part in field_path.split("."):
+        if isinstance(current, dict):
+            if part in current:
+                current = current[part]
+            else:
+                return False, None
+            continue
+
+        if isinstance(current, list):
+            if part.isdigit():
+                idx = int(part)
+                if 0 <= idx < len(current):
+                    current = current[idx]
+                else:
+                    return False, None
+                continue
+            return False, None
+
+        return False, None
+
+    return True, current

regsim/core/simulation.py

@@ -0,0 +1,110 @@
+import json
+import os
+from pathlib import Path
+
+import jsonschema
+
+from regsim.core.evaluator import evaluate_condition
+from regsim.engine import InvalidPayloadError, validate_rules
+
+
+def load_json(path: str):
+    raw = Path(path).read_text().strip()
+    if not raw:
+        raise ValueError(f"{path} is empty")
+    return json.loads(raw)
+
+
+def load_rules(path: str):
+    if os.path.isdir(path):
+        rules = []
+        for root, dirs, files in os.walk(path):
+            dirs.sort()
+            for filename in sorted(files):
+                if not filename.endswith(".json"):
+                    continue
+                file_path = os.path.join(root, filename)
+                data = load_json(file_path)
+                if isinstance(data, list):
+                    rules.extend(data)
+                else:
+                    rules.append(data)
+        return rules
+
+    data = load_json(path)
+    return data if isinstance(data, list) else [data]
+
+def load_schema(schema_name: str) -> dict:
+    schema_path = Path(__file__).resolve().parents[1] / "schemas" / schema_name
+    raw = schema_path.read_text().strip()
+    if not raw:
+        raise ValueError(f"{schema_path} is empty")
+    return json.loads(raw)
+
+
+def validate_rules_schema(rules):
+    if not isinstance(rules, list):
+        raise ValueError("Rules must be a JSON array")
+
+    schema = load_schema("rule.schema.json")
+    for rule in rules:
+        try:
+            jsonschema.validate(instance=rule, schema=schema)
+        except jsonschema.ValidationError as e:
+            rule_id = rule.get("rule_id") if isinstance(rule, dict) else None
+            raise ValueError(
+                f"Rule schema validation failed: {e.message} ({rule_id})"
+            ) from e
+
+
+def simulate(rules, payload, snapshot_date=None) -> dict:
+    if not isinstance(payload, dict):
+        raise InvalidPayloadError("Input payload must be a JSON object")
+
+    validate_rules_schema(rules)
+    validate_rules(rules)
+
+    violations = []
+    applied_rules = []
+
+    for rule in rules:
+        applied_rules.append({
+            "rule_id": rule.get("rule_id"),
+            "rule_version": rule.get("rule_version"),
+            "effective_from": rule.get("effective_from"),
+            "source_reference": rule.get("source_reference"),
+        })
+
+        condition = rule["condition"]
+        action = rule["action"]
+
+        if evaluate_condition(condition, payload):
+            if action["type"] == "FAIL":
+                violations.append({
+                    "rule_id": rule["rule_id"],
+                    "rule_version": rule.get("rule_version"),
+                    "severity": action.get("severity", "HIGH"),
+                    "message": action["message"],
+                    "risk": action.get("risk"),
+                    "source_reference": rule.get("source_reference"),
+                })
+
+    status = "FAIL" if violations else "PASS"
+
+    return {
+        "status": status,
+        "violations": violations,
+        "metadata": {
+            "engine": "regsim-in",
+            "engine_version": "0.1.0",
+            "rule_snapshot": snapshot_date,
+            "applied_rules": applied_rules,
+        },
+    }
+
+
+def run_simulation(rules_path: str, input_path: str) -> dict:
+    rules = load_rules(rules_path)
+    payload = load_json(input_path)
+
+    return simulate(rules, payload)

regsim/core/validators.py

@@ -0,0 +1,9 @@
+import re
+
+GSTIN_REGEX = re.compile(r"^[0-9]{2}[A-Z]{5}[0-9]{4}[A-Z]{1}[1-9A-Z]{1}Z[0-9A-Z]{1}$")
+
+
+def is_invalid_gstin(value):
+    if not isinstance(value, str):
+        return True
+    return not bool(GSTIN_REGEX.match(value))

regsim/engine.py

@@ -0,0 +1,55 @@
+def get_field(payload, field_path):
+    """
+    Fetch nested fields like payment.amount.
+    Returns a tuple: (found, value)
+    """
+    parts = field_path.split(".")
+    current = payload
+
+    for part in parts:
+        if not isinstance(current, dict):
+            return False, None
+        if part not in current:
+            return False, None
+        current = current[part]
+
+    return True, current
+
+
+class InvalidPayloadError(Exception):
+    pass
+
+
+REQUIRED_RULE_FIELDS = [
+    "rule_id",
+    "rule_version",
+    "effective_from",
+    "condition",
+    "action",
+]
+
+
+def validate_rules(rules):
+    for rule in rules:
+        for field in REQUIRED_RULE_FIELDS:
+            if field not in rule:
+                raise ValueError(
+                    f"Rule missing required field: {field} ({rule.get('rule_id')})"
+                )
+
+
+def simulate(rules,payload):
+    if not isinstance(payload, dict):
+        raise InvalidPayloadError("Input payload must be a JSON object")
+
+    validate_rules(rules)
+    
+    return{
+        # place holder logic
+        "status":"PASS",
+        "violations":[],
+        "metadata":{
+            "engine":"regsim-in",
+            "version":"0.1.0"
+        }
+    }

regsim/parser.py

@@ -0,0 +1,36 @@
+import ast
+
+from regsim.utils import extract_call_args, extract_dict, get_func_name
+
+class ExtractionResult:
+    def __init__(self):
+        self.payloads = []
+        self.errors = []
+
+def extract_from_file(file_path):
+    result = ExtractionResult()
+
+    try:
+        with open(file_path, "r") as f:
+            tree = ast.parse(f.read())
+    except Exception as e:
+        result.errors.append(str(e))
+        return result
+
+    for node in ast.walk(tree):
+        # Detect dict literals assigned to variables
+        if isinstance(node, ast.Assign):
+            if isinstance(node.value, ast.Dict):
+                payload = extract_dict(node.value)
+                if payload:
+                    result.payloads.append(payload)
+
+        # Detect function calls like payout(...)
+        if isinstance(node, ast.Call):
+            func_name = get_func_name(node)
+            if func_name and "payout" in func_name.lower():
+                payload = extract_call_args(node)
+                if payload:
+                    result.payloads.append(payload)
+
+    return result

regsim/schemas/input.schema.json

@@ -0,0 +1,4 @@
+{
+  "type": "object",
+  "additionalProperties": true
+}

regsim/schemas/output.schema.json

@@ -0,0 +1,92 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "RegSim-IN Evaluation Result",
+  "type": "object",
+  "required": ["status", "violations"],
+  "properties": {
+    "status": {
+      "type": "string",
+      "enum": ["PASS", "FAIL", "ERROR"],
+      "description": "Overall regulatory evaluation outcome"
+    },
+
+    "violations": {
+      "type": "array",
+      "description": "List of regulatory objections raised during evaluation",
+      "items": {
+        "type": "object",
+        "required": [
+          "rule_id",
+          "rule_version",
+          "severity",
+          "message"
+        ],
+        "properties": {
+          "rule_id": {
+            "type": "string",
+            "description": "Identifier of the violated rule"
+          },
+
+          "rule_version": {
+            "type": "string",
+            "description": "Version of the rule that was evaluated"
+          },
+
+          "authority": {
+            "type": "string",
+            "enum": ["CBDT", "GST", "RBI"],
+            "description": "Regulatory authority raising the objection"
+          },
+
+          "severity": {
+            "type": "string",
+            "enum": ["LOW", "MEDIUM", "HIGH", "CRITICAL"],
+            "description": "Regulatory risk level of the violation"
+          },
+
+          "message": {
+            "type": "string",
+            "description": "Human-readable explanation of the violation"
+          },
+
+          "source_reference": {
+            "type": "string",
+            "description": "Legal basis for the violation"
+          },
+
+          "risk": {
+            "type": "string",
+            "description": "Operational or compliance risk summary"
+          },
+
+          "evidence": {
+            "type": "object",
+            "description": "Facts that caused this rule to trigger"
+          }
+        }
+      }
+    },
+
+    "metadata": {
+      "type": "object",
+      "description": "Execution metadata (engine info, snapshot, applied rules, etc.)",
+      "properties": {
+        "engine": { "type": "string" },
+        "engine_version": { "type": "string" },
+        "rule_snapshot": { "type": ["string", "null"] },
+        "applied_rules": {
+          "type": "array",
+          "items": {
+            "type": "object",
+            "properties": {
+              "rule_id": { "type": "string" },
+              "rule_version": { "type": "string" },
+              "effective_from": { "type": "string", "format": "date" },
+              "source_reference": { "type": "string" }
+            }
+          }
+        }
+      }
+    }
+  }
+}

regsim/schemas/rule.schema.json

@@ -0,0 +1,90 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "RegSim-IN Rule Schema",
+  "type": "object",
+  "required": [
+    "rule_id",
+    "rule_version",
+    "effective_from",
+    "condition",
+    "action"
+  ],
+  "properties": {
+    "rule_id": {
+      "type": "string",
+      "description": "Stable identifier for the regulatory rule"
+    },
+
+    "rule_version": {
+      "type": "string",
+      "description": "Semantic or date-based version of the rule"
+    },
+
+    "authority": {
+      "type": "string",
+      "enum": ["CBDT", "GST", "RBI"],
+      "description": "Regulatory authority owning this rule"
+    },
+
+    "jurisdiction": {
+      "type": "string",
+      "description": "Geographic or legal scope (e.g. IN, IN-KA, CROSS_BORDER)"
+    },
+
+    "effective_from": {
+      "type": "string",
+      "format": "date",
+      "description": "Date from which the rule is legally applicable"
+    },
+
+    "effective_to": {
+      "type": "string",
+      "format": "date",
+      "description": "Date until which the rule is applicable"
+    },
+
+    "severity": {
+      "type": "string",
+      "enum": ["LOW", "MEDIUM", "HIGH", "CRITICAL"],
+      "description": "Risk level from a regulatory perspective"
+    },
+
+    "description": {
+      "type": "string",
+      "description": "Human-readable explanation of the rule intent"
+    },
+
+    "condition": {
+      "type": "object",
+      "description": "Declarative conditions that determine rule applicability"
+    },
+
+    "action": {
+      "type": "object",
+      "required": ["type", "message"],
+      "properties": {
+        "type": {
+          "type": "string",
+          "enum": ["FAIL", "WARN", "PASS"],
+          "description": "Outcome when the rule condition is satisfied"
+        },
+
+        "message": {
+          "type": "string",
+          "description": "Explanation shown to developers or auditors"
+        },
+
+        "evidence_fields": {
+          "type": "array",
+          "items": { "type": "string" },
+          "description": "Fact fields that triggered the rule"
+        }
+      }
+    },
+
+    "source_reference": {
+      "type": "string",
+      "description": "Legal reference (Act section, circular, notification)"
+    }
+  }
+}

regsim/utils/__init__.py

@@ -0,0 +1,9 @@
+__all__ = [
+    "extract_call_args",
+    "extract_dict",
+    "get_func_name",
+]
+
+from regsim.utils.extract_call_args import extract_call_args
+from regsim.utils.extract_dic import extract_dict
+from regsim.utils.get_func_name import get_func_name

regsim/utils/extract_call_args.py

@@ -0,0 +1,10 @@
+import ast
+
+def extract_call_args(call_node):
+    payload = {}
+
+    for kw in call_node.keywords:
+        if isinstance(kw.value, ast.Constant):
+            payload[kw.arg] = kw.value.value
+
+    return payload if payload else None

regsim/utils/extract_dic.py

@@ -0,0 +1,11 @@
+import ast
+
+def extract_dict(node):
+    payload = {}
+
+    for key, value in zip(node.keys, node.values):
+        if isinstance(key, ast.Constant):
+            if isinstance(value, ast.Constant):
+                payload[key.value] = value.value
+
+    return payload if payload else None

regsim/utils/get_func_name.py

@@ -0,0 +1,8 @@
+import ast
+
+def get_func_name(call_node):
+    if isinstance(call_node.func, ast.Name):
+        return call_node.func.id
+    if isinstance(call_node.func, ast.Attribute):
+        return call_node.func.attr
+    return None

regsim_in-0.1.0.dist-info/METADATA

@@ -0,0 +1,324 @@
+Metadata-Version: 2.4
+Name: regsim-in
+Version: 0.1.0
+Summary: Regulatory Simulation CLI for Indian Backend Systems
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: jsonschema>=4.0.0
+
+# RegSim-IN
+
+**Regulatory Simulation & Failure Memory CLI for Indian Backend Systems**
+
+---
+
+## What is RegSim-IN?
+
+**RegSim-IN** is a **developer-first CLI** that simulates Indian regulatory rules (TDS, GST, RBI-style constraints) against backend data flows **before production**.
+
+It helps backend teams **detect, explain, and remember regulatory failures** early — during development, testing, and CI — instead of discovering them during audits or incidents.
+
+RegSim-IN treats regulation as **executable rules**, not PDFs.
+
+---
+
+## What Problem Does This Solve?
+
+Backend teams frequently:
+
+* Ship compliant-looking code that fails under real regulatory edge cases
+* Discover issues late (audits, settlements, reversals)
+* Repeat the *same regulatory mistakes* across services and teams
+
+RegSim-IN exists to:
+
+* Shift regulatory failures **left**
+* Make rules **explicit and testable**
+* Prevent **repeat regulatory incidents**
+
+---
+
+## What RegSim-IN v1 Does 
+
+Version 1 focuses on **deterministic rule simulation**.
+
+RegSim-IN v1 can:
+
+* Load regulatory rules defined in **JSON**
+* Run those rules against input payloads (also JSON)
+* Evaluate pass/fail conditions
+* Emit **machine-readable JSON output**
+* Explain *why* a rule failed
+
+This makes RegSim-IN suitable for:
+
+* Local development checks
+* CI/CD gates
+* Backend design validation
+* Regulatory edge-case exploration
+
+---
+
+## Example: Detecting a Missed TDS Deduction
+
+Consider a backend payout flow where a contractor payment is executed without deducting TDS.
+
+**Input payload:**
+```json
+{
+  "payment": {
+    "id": "pay_1029",
+    "amount": 45000,
+    "vendor_type": "contractor",
+    "tds_deducted": false
+  }
+}
+```
+
+**Simulation result:**
+
+```json
+{
+  "status": "FAIL",
+  "violations": [
+    {
+      "rule_id": "TDS_194C_THRESHOLD",
+      "severity": "HIGH",
+      "message": "TDS must be deducted under section 194C"
+    }
+  ]
+}
+```
+
+This allows teams to catch deduction timing and threshold violations **before** payouts reach production systems.
+
+---
+
+## What RegSim-IN Explicitly Does NOT Do 
+
+To avoid misuse or false confidence, RegSim-IN v1 does **not**:
+
+*  Provide legal, tax, or regulatory advice
+*  File or generate GST / TDS / RBI reports
+*  Integrate with government, bank, or tax APIs
+*  Automatically update rules from circulars
+*  Fully simulate async systems (queues, retries, persistent state)
+
+**This is a simulation tool, not a compliance authority.**
+
+---
+
+## Supported Languages
+
+* **Python** (v1)
+
+The CLI is language-agnostic, but rule evaluation currently targets Python-style backend data models.
+
+---
+
+## Rule Format
+
+Rules are defined in **JSON**.
+
+Design goals:
+
+* Explicit structure
+* Deterministic evaluation
+* Easy diffing & review
+* CI/CD friendliness
+
+### Example Rule
+
+```json
+{
+  "rule_id": "TDS_194C_THRESHOLD",
+  "rule_version": "1.0",
+  "effective_from": "2024-04-01",
+  "description": "TDS applies if contractor payment exceeds threshold",
+  "condition": {
+    "field": "payment.amount",
+    "operator": ">",
+    "value": 30000
+  },
+  "action": {
+    "type": "FAIL",
+    "message": "TDS must be deducted under section 194C"
+  },
+  "source_reference": "Income Tax Act - Section 194C"
+}
+```
+
+---
+
+## Input Format
+
+Inputs represent **backend payloads or traces**, also in JSON.
+
+---
+
+## Output Format
+
+All outputs are **JSON only**.
+
+Example failure output:
+
+```json
+{
+  "status": "FAIL",
+  "violations": [
+    {
+      "rule_id": "TDS_194C_THRESHOLD",
+      "severity": "HIGH",
+      "message": "TDS must be deducted under section 194C"
+    }
+  ],
+  "metadata": {
+    "engine": "regsim-in",
+    "engine_version": "0.1.0",
+    "rule_snapshot": "2024-04-01",
+    "applied_rules": [
+      {
+        "rule_id": "TDS_194C_THRESHOLD",
+        "rule_version": "1.0",
+        "effective_from": "2024-04-01",
+        "source_reference": "Income Tax Act - Section 194C"
+      }
+    ]
+  }
+}
+```
+
+This makes RegSim-IN suitable for automation and tooling.
+
+---
+
+## Error Output
+
+Errors are always returned as JSON and never include a Python traceback:
+
+```json
+{
+  "status": "ERROR",
+  "message": "Rule validation failed: missing field 'action'"
+}
+```
+
+---
+
+## Installation (Early Prototype)
+
+```bash
+pip install regsim-in
+```
+
+>  RegSim-IN is under active development.
+
+---
+
+## Usage (v1)
+
+```bash
+regsim-in simulate \
+  --rules rules/ \
+  --input input.json
+```
+
+Current v1 behavior:
+
+* CLI initializes correctly
+* Rules are parsed and validated
+* Simulation runs deterministically
+* JSON output is emitted
+
+---
+
+## Project Layout (Current)
+
+```
+regsim/
+  cli.py
+  commands/
+    simulate.py
+  core/
+    evaluator.py
+    fields.py
+    simulation.py
+    validators.py
+  schemas/
+```
+
+The CLI stays thin, while core rule evaluation lives under `regsim/core/`.
+
+---
+
+## Rule Versioning & Regulatory Drift
+
+RegSim-IN v1 supports **explicit rule versioning**:
+
+* Rules declare:
+
+  * `rule_version`
+  * `effective_from`
+  * `source_reference`
+* No rule updates happen implicitly
+* Simulations are always tied to a known regulatory snapshot
+
+This ensures:
+
+* Reproducibility
+* Reviewability
+* Trust
+
+---
+
+## CI/CD Usage Example
+
+```bash
+regsim-in simulate --rules rules/ --input payload.json || exit 1
+```
+
+A failing rule causes a non-zero exit code.
+
+---
+
+## Roadmap (Explicit, Not Promised)
+
+Planned future directions include:
+
+* Regulatory failure memory & correlation
+* Safer rule authoring workflows
+* Async system modeling hooks
+* Community-contributed rule sets
+
+These are **not part of v1**.
+
+---
+
+## Philosophy
+
+* Simulation over certification
+* Explicit rules over implicit assumptions
+* Deterministic behavior over magic
+* Memory over repetition
+
+---
+
+## Disclaimer 
+
+RegSim-IN is a **developer simulation tool**.
+It does **not** guarantee legal or regulatory compliance.
+
+Always consult qualified professionals for real-world compliance decisions
+
+---
+
+## Exact Commands
+
+# Run against JSON payload
+regsim-in simulate --rules rules/ --input payload.json
+
+# Run against Python service
+regsim-in simulate --rules rules/ --input src/
+
+# CI usage
+regsim-in simulate --rules rules/ --input src/ --snapshot-date 2024-04-01

regsim_in-0.1.0.dist-info/RECORD

@@ -0,0 +1,24 @@
+regsim/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+regsim/cli.py,sha256=g1PeXT5ZRwdm700FS4Hv5v1hYgDP6X8mrWfiVKjYizU,3481
+regsim/engine.py,sha256=4ApvAIo0aPyHyvugk2hsmRfU4E-7Tja199KbxzrVYZ4,1204
+regsim/errors.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+regsim/parser.py,sha256=kivTrtEn_retMjaFyibZTMIlzRV1oLJudoDRbzpUXT4,1076
+regsim/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+regsim/commands/simulate.py,sha256=Z4c5A_t5lS0D-tV2EVsfTz8Obt4fITHmnhxnRLcAfZg,111
+regsim/core/__init__.py,sha256=IyAjq1BAyLtSfqXjApMUC6EL5kik2dG1LunGuMObTGQ,80
+regsim/core/evaluator.py,sha256=aMPuHUsxthcF-GxUi4YGwktbusSuDAgCaxX31qNcBLg,1979
+regsim/core/fields.py,sha256=r8pk3ry6GdvMNa044x3p_89V0SW3EIjco1Jg5RzPya0,753
+regsim/core/simulation.py,sha256=fqnyeMiNK9QRnNXfzaTmqow13Ni9H_bWApDw5BruvB8,3354
+regsim/core/validators.py,sha256=h6q7wLAIKsnUK7_HOx5HnflLU8iHmFOts3KIg99U81w,230
+regsim/schemas/input.schema.json,sha256=Wm2xgC1_NRUGBnj3eQY2hCDhbwAtx2DVnmLFptiqwjw,55
+regsim/schemas/output.schema.json,sha256=EI1Y18TcNHKv6T1nkPSGOmMEYejdVTWtjGFfeFnpi8I,2566
+regsim/schemas/rule.schema.json,sha256=tG4xSrPWcaKEjpddX1mKAPysx8PeAWPac_eFjs22djc,2201
+regsim/utils/__init__.py,sha256=Y12Xi4a4hVUw_SVAXT0l2uDjBOABlmfPpsyoZtF3HMg,245
+regsim/utils/extract_call_args.py,sha256=hOEFgf-q9VXON7a_UR1nhu2joerzfcKddtu7pZWIyA8,231
+regsim/utils/extract_dic.py,sha256=R2ZzZXndDS77Nj1b8WGp1DXD5N7x7xWzUF5U4DB2NbA,285
+regsim/utils/get_func_name.py,sha256=NF7GpDaH62r5jxCF_wA7rJP44COkRnjs8Ak7lcUp2RA,221
+regsim_in-0.1.0.dist-info/METADATA,sha256=FKVa9v92-cTgpaZlkOdbQ1LLwClAgLRl9ytPtN-OKFs,6330
+regsim_in-0.1.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+regsim_in-0.1.0.dist-info/entry_points.txt,sha256=9XtjTQnV-P6spTRQfs8RyvBkAJjyVgsyVCvu3XVWJdw,46
+regsim_in-0.1.0.dist-info/top_level.txt,sha256=v8qlZho0FIeDZFo2-rN6-vSbtXtZJ6LIPwXei87wRzY,7
+regsim_in-0.1.0.dist-info/RECORD,,

regsim_in-0.1.0.dist-info/WHEEL

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

regsim_in-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+regsim-in = regsim.cli:main

regsim_in-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+regsim