daytashield 0.1.1__py3-none-any.whl

daytashield/validators/semantic.py

@@ -0,0 +1,256 @@
+"""Semantic validation using LLMs."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from typing import Any
+
+from pydantic import Field
+
+from daytashield.core.result import ValidationResult, ValidationStatus
+from daytashield.validators.base import BaseValidator, ValidatorConfig
+
+
+class SemanticValidatorConfig(ValidatorConfig):
+    """Configuration for semantic validation."""
+
+    model: str = Field("gpt-4o-mini", description="LLM model to use")
+    temperature: float = Field(0.0, description="LLM temperature (0 for deterministic)")
+    max_tokens: int = Field(500, description="Maximum response tokens")
+    cache_results: bool = Field(True, description="Cache validation results")
+    timeout: int = Field(30, description="Request timeout in seconds")
+    api_base: str | None = Field(None, description="Custom API base URL")
+
+
+class SemanticValidator(BaseValidator):
+    """Validates data semantically using LLMs.
+
+    Uses language models to perform content-based validation that goes
+    beyond schema checking. Useful for:
+    - Checking if content is appropriate/relevant
+    - Verifying factual consistency
+    - Detecting anomalies or outliers
+    - Domain-specific validation rules
+
+    Example:
+        >>> validator = SemanticValidator(
+        ...     prompt="Check if this document is a valid invoice with required fields",
+        ...     criteria=["has_invoice_number", "has_date", "has_line_items", "has_total"],
+        ... )
+        >>> result = validator.validate(document_data, result)
+
+    The validator uses LiteLLM for provider-agnostic LLM access, supporting
+    OpenAI, Anthropic, local models, and more.
+    """
+
+    name = "semantic"
+
+    def __init__(
+        self,
+        prompt: str,
+        criteria: list[str] | None = None,
+        config: SemanticValidatorConfig | dict[str, Any] | None = None,
+    ):
+        """Initialize the semantic validator.
+
+        Args:
+            prompt: The validation prompt describing what to check
+            criteria: List of specific criteria to evaluate
+            config: Validator configuration
+        """
+        if config is None:
+            super().__init__(SemanticValidatorConfig())
+        elif isinstance(config, dict):
+            super().__init__(SemanticValidatorConfig(**config))
+        else:
+            super().__init__(config)
+
+        self.prompt = prompt
+        self.criteria = criteria or []
+        self._cache: dict[str, dict[str, Any]] = {}
+
+    def validate(self, data: Any, result: ValidationResult) -> ValidationResult:
+        """Validate data semantically using an LLM.
+
+        Args:
+            data: The data to validate
+            result: The ValidationResult to update
+
+        Returns:
+            Updated ValidationResult
+        """
+        config = self.config
+        if not isinstance(config, SemanticValidatorConfig):
+            config = SemanticValidatorConfig()
+
+        # Generate cache key
+        cache_key = self._get_cache_key(data)
+        if config.cache_results and cache_key in self._cache:
+            return self._apply_cached_result(result, self._cache[cache_key])
+
+        # Build the validation prompt
+        system_prompt = self._build_system_prompt()
+        user_prompt = self._build_user_prompt(data)
+
+        try:
+            # Import litellm here to make it optional
+            import litellm
+
+            # Configure litellm
+            if config.api_base:
+                litellm.api_base = config.api_base
+
+            # Make the LLM call
+            response = litellm.completion(
+                model=config.model,
+                messages=[
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": user_prompt},
+                ],
+                temperature=config.temperature,
+                max_tokens=config.max_tokens,
+                timeout=config.timeout,
+                response_format={"type": "json_object"},
+            )
+
+            # Parse the response
+            response_text = response.choices[0].message.content
+            validation_result = json.loads(response_text)
+
+            # Cache the result
+            if config.cache_results:
+                self._cache[cache_key] = validation_result
+
+            # Apply the result
+            return self._apply_validation_result(result, validation_result)
+
+        except ImportError:
+            result.add_message(
+                code="SEMANTIC_NO_LITELLM",
+                message="litellm package not installed. Install with: pip install litellm",
+                severity=ValidationStatus.ERROR,
+                validator=self.name,
+            )
+            result.status = ValidationStatus.ERROR
+            return result
+
+        except json.JSONDecodeError as e:
+            result.add_message(
+                code="SEMANTIC_PARSE_ERROR",
+                message=f"Failed to parse LLM response as JSON: {e}",
+                severity=ValidationStatus.ERROR,
+                validator=self.name,
+            )
+            result.status = ValidationStatus.ERROR
+            return result
+
+        except Exception as e:
+            result.add_message(
+                code="SEMANTIC_LLM_ERROR",
+                message=f"LLM validation failed: {e}",
+                severity=ValidationStatus.ERROR,
+                validator=self.name,
+                details={"error": str(e)},
+            )
+            result.status = ValidationStatus.ERROR
+            return result
+
+    def _build_system_prompt(self) -> str:
+        """Build the system prompt for the LLM."""
+        criteria_text = ""
+        if self.criteria:
+            criteria_list = "\n".join(f"- {c}" for c in self.criteria)
+            criteria_text = f"\n\nSpecific criteria to evaluate:\n{criteria_list}"
+
+        return f"""You are a data validation assistant. Your task is to validate data based on the given criteria and return a structured JSON response.
+
+Validation task: {self.prompt}{criteria_text}
+
+IMPORTANT: Respond ONLY with valid JSON in this exact format:
+{{
+    "valid": true/false,
+    "confidence": 0.0-1.0,
+    "issues": [
+        {{
+            "criterion": "criterion_name",
+            "passed": true/false,
+            "message": "explanation"
+        }}
+    ],
+    "summary": "brief overall assessment"
+}}"""
+
+    def _build_user_prompt(self, data: Any) -> str:
+        """Build the user prompt with the data to validate."""
+        if isinstance(data, dict):
+            data_str = json.dumps(data, indent=2, default=str)
+        elif isinstance(data, str):
+            data_str = data
+        else:
+            data_str = str(data)
+
+        return f"""Please validate the following data:
+
+```
+{data_str[:10000]}
+```
+
+Return your validation result as JSON."""
+
+    def _get_cache_key(self, data: Any) -> str:
+        """Generate a cache key for the data."""
+        data_str = json.dumps(data, sort_keys=True, default=str) if isinstance(data, dict) else str(data)
+        content = f"{self.prompt}:{self.criteria}:{data_str}"
+        return hashlib.sha256(content.encode()).hexdigest()[:16]
+
+    def _apply_validation_result(
+        self, result: ValidationResult, validation: dict[str, Any]
+    ) -> ValidationResult:
+        """Apply the LLM validation result to the ValidationResult."""
+        is_valid = validation.get("valid", False)
+        confidence = validation.get("confidence", 0.0)
+        issues = validation.get("issues", [])
+        summary = validation.get("summary", "")
+
+        # Add metadata
+        result.metadata["semantic_confidence"] = confidence
+        result.metadata["semantic_summary"] = summary
+
+        # Process issues
+        for issue in issues:
+            if not issue.get("passed", True):
+                severity = ValidationStatus.WARNING if confidence > 0.5 else ValidationStatus.FAILED
+                result.add_message(
+                    code="SEMANTIC_CRITERION_FAILED",
+                    message=issue.get("message", "Criterion not met"),
+                    severity=severity,
+                    validator=self.name,
+                    field=issue.get("criterion"),
+                    details={"confidence": confidence},
+                )
+
+        # Update status
+        if not is_valid:
+            if confidence < 0.5:
+                result.status = ValidationStatus.FAILED
+            else:
+                # High confidence but invalid = warning
+                if result.status != ValidationStatus.FAILED:
+                    result.status = ValidationStatus.WARNING
+
+        return result
+
+    def _apply_cached_result(
+        self, result: ValidationResult, cached: dict[str, Any]
+    ) -> ValidationResult:
+        """Apply a cached validation result."""
+        result.metadata["semantic_cached"] = True
+        return self._apply_validation_result(result, cached)
+
+    def clear_cache(self) -> None:
+        """Clear the validation cache."""
+        self._cache.clear()
+
+    def __repr__(self) -> str:
+        return f"SemanticValidator(prompt={self.prompt[:50]!r}..., criteria={len(self.criteria)})"

daytashield-0.1.1.dist-info/METADATA

@@ -0,0 +1,316 @@
+Metadata-Version: 2.4
+Name: daytashield
+Version: 0.1.1
+Summary: The missing validation layer between unstructured data and AI systems
+Project-URL: Homepage, https://github.com/daytashield/daytashield
+Project-URL: Documentation, https://daytashield.dev/docs
+Project-URL: Repository, https://github.com/daytashield/daytashield
+Project-URL: Issues, https://github.com/daytashield/daytashield/issues
+Author-email: DaytaShield Team <team@daytashield.dev>
+License-Expression: Apache-2.0
+License-File: LICENSE
+Keywords: ai,compliance,data-validation,gdpr,hipaa,langchain,llm,multimodal,rag
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+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: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Requires-Dist: click>=8.0
+Requires-Dist: eval-type-backport>=0.2.0; python_version < '3.10'
+Requires-Dist: jsonschema>=4.0
+Requires-Dist: langchain-core>=0.1
+Requires-Dist: litellm>=1.0
+Requires-Dist: orjson>=3.9
+Requires-Dist: pandas>=2.0
+Requires-Dist: pdfplumber>=0.10
+Requires-Dist: pydantic>=2.0
+Requires-Dist: python-dateutil>=2.8
+Requires-Dist: rich>=13.0
+Provides-Extra: all
+Requires-Dist: mkdocs-material>=9.0; extra == 'all'
+Requires-Dist: mkdocs>=1.5; extra == 'all'
+Requires-Dist: mkdocstrings[python]>=0.24; extra == 'all'
+Requires-Dist: mypy>=1.0; extra == 'all'
+Requires-Dist: pandas-stubs>=2.0; extra == 'all'
+Requires-Dist: pillow; extra == 'all'
+Requires-Dist: pre-commit>=3.0; extra == 'all'
+Requires-Dist: pytesseract; extra == 'all'
+Requires-Dist: pytest-asyncio>=0.21; extra == 'all'
+Requires-Dist: pytest-cov>=4.0; extra == 'all'
+Requires-Dist: pytest>=7.0; extra == 'all'
+Requires-Dist: ruff>=0.1; extra == 'all'
+Provides-Extra: dev
+Requires-Dist: mypy>=1.0; extra == 'dev'
+Requires-Dist: pandas-stubs>=2.0; extra == 'dev'
+Requires-Dist: pre-commit>=3.0; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.21; extra == 'dev'
+Requires-Dist: pytest-cov>=4.0; extra == 'dev'
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Requires-Dist: ruff>=0.1; extra == 'dev'
+Provides-Extra: docs
+Requires-Dist: mkdocs-material>=9.0; extra == 'docs'
+Requires-Dist: mkdocs>=1.5; extra == 'docs'
+Requires-Dist: mkdocstrings[python]>=0.24; extra == 'docs'
+Provides-Extra: ocr
+Requires-Dist: pillow; extra == 'ocr'
+Requires-Dist: pytesseract; extra == 'ocr'
+Description-Content-Type: text/markdown
+
+# 🛡️ DaytaShield
+
+[![PyPI version](https://badge.fury.io/py/daytashield.svg)](https://badge.fury.io/py/daytashield)
+[![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
+[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
+
+**The missing validation layer between unstructured data and AI systems.**
+
+DaytaShield validates multimodal data (PDFs, CSVs, JSON, images) before it reaches your RAG pipelines, AI agents, or analytics systems. Stop hallucinations at the source.
+
+## 🚀 Quick Start
+
+```bash
+pip install daytashield
+```
+
+```python
+from daytashield import ValidationPipeline, SchemaValidator, FreshnessValidator
+
+# Create a validation pipeline
+pipeline = ValidationPipeline([
+    SchemaValidator(schema={"type": "object", "required": ["id", "content"]}),
+    FreshnessValidator(max_age="7d"),
+])
+
+# Validate your data
+result = pipeline.validate({
+    "id": 1,
+    "content": "Hello world",
+    "timestamp": "2024-01-15"
+})
+
+print(result.status)  # ValidationStatus.PASSED
+```
+
+## ✨ Features
+
+- **📋 Schema Validation** - JSON Schema + Pydantic model validation
+- **🧠 Semantic Validation** - LLM-powered content validation
+- **⏰ Freshness Checks** - Detect stale data before it causes problems
+- **🔒 Compliance Rules** - Built-in HIPAA, GDPR, and PII detection
+- **📄 Document Processing** - PDF, CSV, JSON extraction and validation
+- **🔗 LangChain Integration** - Validated retrievers for RAG pipelines
+- **📊 Audit Trail** - Immutable logging for compliance
+
+## 📖 Usage
+
+### Validate Files
+
+```python
+from daytashield import ValidationPipeline, SchemaValidator, PDFProcessor
+
+# Create pipeline with processors
+pipeline = ValidationPipeline([
+    SchemaValidator(schema=invoice_schema),
+])
+pipeline.add_processor(".pdf", PDFProcessor())
+
+# Validate a PDF
+result = pipeline.validate_file("invoice.pdf")
+if result.failed:
+    for error in result.errors:
+        print(f"Error: {error.message}")
+```
+
+### Compliance Checking
+
+```python
+from daytashield import ValidationPipeline, ComplianceValidator
+
+# Check for HIPAA and PII violations
+pipeline = ValidationPipeline([
+    ComplianceValidator(rules=["hipaa", "pii"]),
+])
+
+result = pipeline.validate(patient_data)
+for message in result.messages:
+    print(f"{message.severity}: {message.message}")
+```
+
+### LangChain Integration
+
+```python
+from langchain_community.vectorstores import FAISS
+from daytashield import SchemaValidator, FreshnessValidator
+from daytashield.integrations.langchain import ValidatedRetriever
+
+# Wrap your retriever with validation
+retriever = ValidatedRetriever(
+    base_retriever=vectorstore.as_retriever(),
+    validators=[
+        SchemaValidator(schema=doc_schema),
+        FreshnessValidator(max_age="7d"),
+    ],
+    on_fail="filter",  # Remove invalid documents
+)
+
+# Use like any LangChain retriever
+docs = retriever.invoke("What is the refund policy?")
+```
+
+### Routing Based on Validation
+
+```python
+from daytashield import ValidationPipeline, DataRouter, RouteAction
+
+pipeline = ValidationPipeline([...])
+router = DataRouter()
+
+result = pipeline.validate(data)
+decision = router.route(result)
+
+if decision.route.action == RouteAction.PASS:
+    send_to_destination(result.data)
+elif decision.route.action == RouteAction.QUARANTINE:
+    quarantine_for_review(result.data, decision.reason)
+```
+
+## 🖥️ CLI
+
+```bash
+# Validate files
+daytashield validate invoice.pdf --schema invoice.json
+
+# Validate with compliance rules
+daytashield validate ./data/ --rules hipaa --rules pii
+
+# Watch directory for new files
+daytashield watch ./incoming/ --rules hipaa --audit audit.jsonl
+
+# Query audit log
+daytashield audit audit.jsonl --status failed --limit 10
+```
+
+## 📦 Validators
+
+| Validator | Description |
+|-----------|-------------|
+| `SchemaValidator` | JSON Schema and Pydantic validation |
+| `SemanticValidator` | LLM-based content validation |
+| `FreshnessValidator` | Timestamp and staleness checks |
+| `ComplianceValidator` | HIPAA, GDPR, PII rule enforcement |
+
+## 📄 Processors
+
+| Processor | Formats | Description |
+|-----------|---------|-------------|
+| `PDFProcessor` | `.pdf` | Text extraction with pdfplumber |
+| `CSVProcessor` | `.csv`, `.tsv` | Tabular data with pandas |
+| `JSONProcessor` | `.json`, `.jsonl` | Structured data with orjson |
+
+## 🔒 Compliance Rules
+
+| Rule Pack | Coverage |
+|-----------|----------|
+| `hipaa` | PHI detection, medical record numbers, health plan IDs |
+| `gdpr` | Consent checking, special category data, data minimization |
+| `pii` | SSN, credit cards, emails, phone numbers, IP addresses |
+
+## 📊 Audit Trail
+
+DaytaShield maintains an immutable audit log of all validation operations:
+
+```python
+from daytashield import AuditTrail, ValidationPipeline
+
+# Enable audit logging
+audit = AuditTrail("./audit.jsonl")
+pipeline = ValidationPipeline([...])
+
+result = pipeline.validate(data)
+audit.log(result)
+
+# Query the audit trail
+for entry in audit.query(status=ValidationStatus.FAILED):
+    print(f"Failed: {entry.source_id} at {entry.timestamp}")
+
+# Get statistics
+stats = audit.stats()
+print(f"Pass rate: {stats['by_status']['passed'] / stats['total'] * 100:.1f}%")
+```
+
+## 🏗️ Architecture
+
+```
+┌─────────────┐     ┌─────────────┐     ┌─────────────┐
+│   Source    │────▶│  Processor  │────▶│  Validators │
+│ PDF/CSV/JSON│     │  Extract    │     │  Schema     │
+└─────────────┘     └─────────────┘     │  Semantic   │
+                                        │  Freshness  │
+                                        │  Compliance │
+                                        └──────┬──────┘
+                                               │
+                    ┌─────────────┐     ┌──────▼──────┐
+                    │   Audit     │◀────│   Router    │
+                    │   Trail     │     │  Pass/Warn  │
+                    └─────────────┘     │  /Fail      │
+                                        └─────────────┘
+```
+
+## 🔧 Configuration
+
+```python
+from daytashield import ValidationPipeline, PipelineConfig
+
+pipeline = ValidationPipeline(
+    validators=[...],
+    config=PipelineConfig(
+        fail_fast=True,          # Stop on first failure
+        include_original_data=True,  # Keep original data in result
+        auto_detect_processor=True,  # Auto-select processor by extension
+    ),
+)
+```
+
+## 🤝 Contributing
+
+We welcome contributions! Please see [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines.
+
+```bash
+# Clone the repo
+git clone https://github.com/daytashield/daytashield.git
+cd daytashield
+
+# Install dev dependencies
+pip install -e ".[dev]"
+
+# Run tests
+pytest
+
+# Run linting
+ruff check src tests
+```
+
+## 📄 License
+
+Apache 2.0 - see [LICENSE](LICENSE) for details.
+
+## 🔗 Links
+
+- [Documentation](https://daytashield.dev/docs)
+- [PyPI](https://pypi.org/project/daytashield/)
+- [GitHub](https://github.com/daytashield/daytashield)
+- [Discord](https://discord.gg/daytashield)
+
+---
+
+**Built with ❤️ for the AI community**
+
+*Stop bad data at the source. Validate before you hallucinate.*

daytashield-0.1.1.dist-info/RECORD

@@ -0,0 +1,31 @@
+daytashield/__init__.py,sha256=ibXIZN0DYPLL6x4Et-zEWZOn3tdf3zekt4gRFHRZDds,2109
+daytashield/cli/__init__.py,sha256=KGux-93hICSzY5wTnajn7z7S0rteqHk0G9LFgHIP_CY,99
+daytashield/cli/main.py,sha256=Uzxk89lSBqUrYlJQV4NfH1-jgObUazhKuI0wCTa6bIs,15220
+daytashield/core/__init__.py,sha256=swtK_Uxj6eet25AjcEJNTLP9k85HWdOTfDsjVLmmW4A,443
+daytashield/core/audit.py,sha256=cTQYG3OUTmR-R7BQFHm9BwlX-CxfPfF3VjcdHl59u68,9232
+daytashield/core/pipeline.py,sha256=tBuROvwVf0E68cQ0FrdqmKlQgtAPkonmjceIVRueCK0,8383
+daytashield/core/result.py,sha256=DRqkob6NYKQW_tdZMXVes_KCtW_1TSS1eLW_IBRTwO8,6833
+daytashield/core/router.py,sha256=szWpc7NTxyZ4iocbnrxzt0bGf5KgJ9CFYboyKDWKC4o,6972
+daytashield/integrations/__init__.py,sha256=D3uD4WyCMM-UqaEgbfDlQVaEPjDbzwSUQUyOaKTVfwY,165
+daytashield/integrations/langchain.py,sha256=x5aZwHkX0VFeGgq-OeBWGZULyoQQ2cq31jxpiuDzSKM,13340
+daytashield/processors/__init__.py,sha256=8l7q8lzfwKes4FKzbUy0OwmGGlaojFjW_p3l33NRrpE,377
+daytashield/processors/base.py,sha256=HIX_Qd-tinjkZLe-fSV46BeeH-lI1aJAI0dnlBh7EFo,6055
+daytashield/processors/csv.py,sha256=IpbjsuXwc9jjSMO551-gq2SVYrxENapJuSszxlOYrk0,9151
+daytashield/processors/json.py,sha256=gJAb4IhEJwt_U0NQ7du9LPC7HFfMhJzOpGIF0XcsPpU,8723
+daytashield/processors/pdf.py,sha256=vGkD_q1Youib7YTsrCfmpoEvU6LBRXlGIOkgPmGDMUk,7698
+daytashield/rules/__init__.py,sha256=lcmwGft7iVkI2Rplr6p7HxGBcuW1hv5PzGQmQA9bx3Q,369
+daytashield/rules/base.py,sha256=fsliG9OzPfWO67mcUJqNmIchHD8AGr_ITB1Qmk1Sa_w,2375
+daytashield/rules/gdpr.py,sha256=zzZFMZlfiE1uXa82Ekr0eabcJVOs54YmkEDGUNtvF14,11403
+daytashield/rules/hipaa.py,sha256=F3sFcAano34CVp_Gbxzq0hpDYLx8ULnVs-xvYHYR6zc,8006
+daytashield/rules/pii.py,sha256=YAvkD7yVDYNCHWJcuBTBKW6XuCBIV4LgmP9TJYlTTPI,7644
+daytashield/validators/__init__.py,sha256=jb9YIiP8smesZW0lvfoYioSOJFJSjpNXG-TofU3mi80,499
+daytashield/validators/base.py,sha256=E_qB174VaTxAJXYNj033CCo2MCAQCibreuaZeqmp2e8,3417
+daytashield/validators/compliance.py,sha256=aX3sB6rTOklMmSSXZTfXImaqN26xSLsoyU5S7Jcw7vA,7781
+daytashield/validators/freshness.py,sha256=U5Ta8vIWJErOJz1Ahodw2xpMGgTraJq7gxMnYs8yqQI,11279
+daytashield/validators/schema.py,sha256=vJI5V_02PSq-L61fVVptr6M27C1EeBYoLmrqLiLz4M4,5948
+daytashield/validators/semantic.py,sha256=cgTGALC7Jvqnzt_8RanyDBBspKij8LQ4GbcWR5RPCSI,9069
+daytashield-0.1.1.dist-info/METADATA,sha256=wskiF0EK5H9Xh7BbXA2vTc77BEpXontsHxiyMgP-j5g,10320
+daytashield-0.1.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+daytashield-0.1.1.dist-info/entry_points.txt,sha256=HDyDPfM8S9Vllxik1fCxrTQ3CAH5UKUDznqlPTVzTkk,57
+daytashield-0.1.1.dist-info/licenses/LICENSE,sha256=OkFgJ1ml3343f-jCqVLj11Ihv4ieJrIr6leY8AiYTes,10764
+daytashield-0.1.1.dist-info/RECORD,,

daytashield-0.1.1.dist-info/WHEEL

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

daytashield-0.1.1.dist-info/entry_points.txt

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