classifinder 0.1.0__py3-none-any.whl

classifinder/__init__.py

@@ -0,0 +1,49 @@
+"""ClassiFinder Python SDK — scan and redact secrets from text."""
+
+from ._client import ClassiFinder
+from ._async_client import AsyncClassiFinder
+from ._exceptions import (
+    ClassiFinderError,
+    AuthenticationError,
+    RateLimitError,
+    InvalidRequestError,
+    ForbiddenError,
+    ServerError,
+    APIConnectionError,
+    SecretsDetectedError,
+)
+from ._models import (
+    ScanResult,
+    RedactResult,
+    TypesResult,
+    HealthResult,
+    FeedbackResult,
+    Finding,
+    RedactFinding,
+    Span,
+    SeveritySummary,
+    TypeInfo,
+)
+
+__all__ = [
+    "ClassiFinder",
+    "AsyncClassiFinder",
+    "ClassiFinderError",
+    "AuthenticationError",
+    "RateLimitError",
+    "InvalidRequestError",
+    "ForbiddenError",
+    "ServerError",
+    "APIConnectionError",
+    "SecretsDetectedError",
+    "ScanResult",
+    "RedactResult",
+    "TypesResult",
+    "HealthResult",
+    "FeedbackResult",
+    "Finding",
+    "RedactFinding",
+    "Span",
+    "SeveritySummary",
+    "TypeInfo",
+]

classifinder/_async_client.py

@@ -0,0 +1,139 @@
+"""Asynchronous ClassiFinder client."""
+
+from typing import List, Optional
+
+import httpx
+
+from ._base import (
+    DEFAULT_BASE_URL,
+    DEFAULT_MAX_RETRIES,
+    DEFAULT_TIMEOUT,
+    async_sleep_for_retry,
+    build_headers,
+    is_retryable,
+    raise_for_status,
+    resolve_api_key,
+)
+from ._exceptions import APIConnectionError
+from ._models import (
+    FeedbackResult,
+    HealthResult,
+    RedactResult,
+    ScanResult,
+    TypesResult,
+)
+
+
+class AsyncClassiFinder:
+    """Asynchronous client for the ClassiFinder API."""
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        base_url: str = DEFAULT_BASE_URL,
+        max_retries: int = DEFAULT_MAX_RETRIES,
+        timeout: float = DEFAULT_TIMEOUT,
+    ) -> None:
+        self._api_key = resolve_api_key(api_key)
+        self._base_url = base_url.rstrip("/")
+        self._max_retries = max_retries
+        self._client = httpx.AsyncClient(
+            headers=build_headers(self._api_key),
+            timeout=timeout,
+        )
+
+    async def close(self) -> None:
+        """Close the underlying HTTP connection pool."""
+        await self._client.aclose()
+
+    async def __aenter__(self) -> "AsyncClassiFinder":
+        return self
+
+    async def __aexit__(self, *args) -> None:
+        await self.close()
+
+    async def _request(self, method: str, path: str, **kwargs) -> httpx.Response:
+        """Make an HTTP request with retry logic."""
+        url = f"{self._base_url}{path}"
+        last_exc: Optional[Exception] = None
+
+        for attempt in range(self._max_retries + 1):
+            try:
+                response = await self._client.request(method, url, **kwargs)
+                raise_for_status(response)
+                return response
+            except (httpx.TimeoutException, httpx.ConnectError, httpx.NetworkError) as exc:
+                api_exc = APIConnectionError(str(exc))
+                last_exc = api_exc
+                if attempt >= self._max_retries:
+                    raise api_exc from exc
+                await async_sleep_for_retry(attempt, api_exc)
+            except Exception as exc:
+                last_exc = exc
+                if not is_retryable(exc) or attempt >= self._max_retries:
+                    raise
+                await async_sleep_for_retry(attempt, exc)
+
+        raise last_exc  # pragma: no cover
+
+    async def scan(
+        self,
+        text: str,
+        types: Optional[List[str]] = None,
+        min_confidence: float = 0.5,
+        include_context: bool = True,
+    ) -> ScanResult:
+        """Scan text for secrets."""
+        body = {
+            "text": text,
+            "types": types or ["all"],
+            "min_confidence": min_confidence,
+            "include_context": include_context,
+        }
+        response = await self._request("POST", "/v1/scan", json=body)
+        return ScanResult.model_validate(response.json())
+
+    async def redact(
+        self,
+        text: str,
+        types: Optional[List[str]] = None,
+        min_confidence: float = 0.5,
+        redaction_style: str = "label",
+    ) -> RedactResult:
+        """Scan and redact secrets from text."""
+        body = {
+            "text": text,
+            "types": types or ["all"],
+            "min_confidence": min_confidence,
+            "redaction_style": redaction_style,
+        }
+        response = await self._request("POST", "/v1/redact", json=body)
+        return RedactResult.model_validate(response.json())
+
+    async def get_types(self) -> TypesResult:
+        """List all detectable secret types."""
+        response = await self._request("GET", "/v1/types")
+        return TypesResult.model_validate(response.json())
+
+    async def health(self) -> HealthResult:
+        """Check API health."""
+        response = await self._request("GET", "/v1/health")
+        return HealthResult.model_validate(response.json())
+
+    async def feedback(
+        self,
+        request_id: str,
+        finding_id: str,
+        feedback_type: str,
+        comment: Optional[str] = None,
+    ) -> FeedbackResult:
+        """Report a false positive or false negative."""
+        body = {
+            "request_id": request_id,
+            "finding_id": finding_id,
+            "feedback_type": feedback_type,
+        }
+        if comment is not None:
+            body["comment"] = comment
+        response = await self._request("POST", "/v1/feedback", json=body)
+        return FeedbackResult.model_validate(response.json())

classifinder/_base.py

@@ -0,0 +1,104 @@
+"""Shared logic for sync and async clients: error mapping, retry, request building."""
+
+import os
+import time
+from typing import Any, Dict, Optional
+
+import httpx
+
+from ._exceptions import (
+    AuthenticationError,
+    RateLimitError,
+    InvalidRequestError,
+    ForbiddenError,
+    ServerError,
+    APIConnectionError,
+    ClassiFinderError,
+)
+
+DEFAULT_BASE_URL = "https://api.classifinder.tech"
+DEFAULT_TIMEOUT = 30.0
+DEFAULT_MAX_RETRIES = 2
+
+_RETRYABLE_STATUS_CODES = {429, 500}
+
+
+def resolve_api_key(api_key: Optional[str]) -> str:
+    """Resolve API key from argument or CLASSIFINDER_API_KEY env var."""
+    key = api_key or os.environ.get("CLASSIFINDER_API_KEY")
+    if not key:
+        raise AuthenticationError(
+            "No API key provided. Pass api_key= or set the CLASSIFINDER_API_KEY environment variable."
+        )
+    return key
+
+
+def build_headers(api_key: str) -> Dict[str, str]:
+    """Build default request headers."""
+    return {
+        "X-API-Key": api_key,
+        "Content-Type": "application/json",
+    }
+
+
+def raise_for_status(response: httpx.Response) -> None:
+    """Raise the appropriate ClassiFinderError for non-2xx responses."""
+    if response.status_code < 400:
+        return
+
+    try:
+        body = response.json()
+        error = body.get("error", {})
+        message = error.get("message", response.text)
+        code = error.get("code", "")
+        retry_after = error.get("retry_after")
+    except Exception:
+        message = response.text or f"HTTP {response.status_code}"
+        code = ""
+        retry_after = None
+
+    status = response.status_code
+
+    if status == 401:
+        raise AuthenticationError(message)
+    elif status == 400:
+        raise InvalidRequestError(message, code=code)
+    elif status == 403:
+        raise ForbiddenError(message, code=code)
+    elif status == 429:
+        raise RateLimitError(message, retry_after=retry_after or 0)
+    elif status >= 500:
+        raise ServerError(message)
+    else:
+        raise ClassiFinderError(message, status_code=status)
+
+
+def is_retryable(exc: Exception) -> bool:
+    """Check if an exception is retryable."""
+    if isinstance(exc, RateLimitError):
+        return True
+    if isinstance(exc, ServerError):
+        return True
+    if isinstance(exc, APIConnectionError):
+        return True
+    return False
+
+
+def get_retry_delay(attempt: int, exc: Exception) -> float:
+    """Calculate delay before next retry attempt."""
+    if isinstance(exc, RateLimitError) and exc.retry_after > 0:
+        return float(exc.retry_after)
+    return float(2**attempt)
+
+
+def sleep_for_retry(attempt: int, exc: Exception) -> None:
+    """Sleep before a sync retry."""
+    delay = get_retry_delay(attempt, exc)
+    time.sleep(delay)
+
+
+async def async_sleep_for_retry(attempt: int, exc: Exception) -> None:
+    """Sleep before an async retry."""
+    import asyncio
+    delay = get_retry_delay(attempt, exc)
+    await asyncio.sleep(delay)

classifinder/_client.py

@@ -0,0 +1,139 @@
+"""Synchronous ClassiFinder client."""
+
+from typing import List, Optional
+
+import httpx
+
+from ._base import (
+    DEFAULT_BASE_URL,
+    DEFAULT_MAX_RETRIES,
+    DEFAULT_TIMEOUT,
+    build_headers,
+    is_retryable,
+    raise_for_status,
+    resolve_api_key,
+    sleep_for_retry,
+)
+from ._exceptions import APIConnectionError
+from ._models import (
+    FeedbackResult,
+    HealthResult,
+    RedactResult,
+    ScanResult,
+    TypesResult,
+)
+
+
+class ClassiFinder:
+    """Synchronous client for the ClassiFinder API."""
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        base_url: str = DEFAULT_BASE_URL,
+        max_retries: int = DEFAULT_MAX_RETRIES,
+        timeout: float = DEFAULT_TIMEOUT,
+    ) -> None:
+        self._api_key = resolve_api_key(api_key)
+        self._base_url = base_url.rstrip("/")
+        self._max_retries = max_retries
+        self._client = httpx.Client(
+            headers=build_headers(self._api_key),
+            timeout=timeout,
+        )
+
+    def close(self) -> None:
+        """Close the underlying HTTP connection pool."""
+        self._client.close()
+
+    def __enter__(self) -> "ClassiFinder":
+        return self
+
+    def __exit__(self, *args) -> None:
+        self.close()
+
+    def _request(self, method: str, path: str, **kwargs) -> httpx.Response:
+        """Make an HTTP request with retry logic."""
+        url = f"{self._base_url}{path}"
+        last_exc: Optional[Exception] = None
+
+        for attempt in range(self._max_retries + 1):
+            try:
+                response = self._client.request(method, url, **kwargs)
+                raise_for_status(response)
+                return response
+            except (httpx.TimeoutException, httpx.ConnectError, httpx.NetworkError) as exc:
+                api_exc = APIConnectionError(str(exc))
+                last_exc = api_exc
+                if attempt >= self._max_retries:
+                    raise api_exc from exc
+                sleep_for_retry(attempt, api_exc)
+            except Exception as exc:
+                last_exc = exc
+                if not is_retryable(exc) or attempt >= self._max_retries:
+                    raise
+                sleep_for_retry(attempt, exc)
+
+        raise last_exc  # pragma: no cover
+
+    def scan(
+        self,
+        text: str,
+        types: Optional[List[str]] = None,
+        min_confidence: float = 0.5,
+        include_context: bool = True,
+    ) -> ScanResult:
+        """Scan text for secrets."""
+        body = {
+            "text": text,
+            "types": types or ["all"],
+            "min_confidence": min_confidence,
+            "include_context": include_context,
+        }
+        response = self._request("POST", "/v1/scan", json=body)
+        return ScanResult.model_validate(response.json())
+
+    def redact(
+        self,
+        text: str,
+        types: Optional[List[str]] = None,
+        min_confidence: float = 0.5,
+        redaction_style: str = "label",
+    ) -> RedactResult:
+        """Scan and redact secrets from text."""
+        body = {
+            "text": text,
+            "types": types or ["all"],
+            "min_confidence": min_confidence,
+            "redaction_style": redaction_style,
+        }
+        response = self._request("POST", "/v1/redact", json=body)
+        return RedactResult.model_validate(response.json())
+
+    def get_types(self) -> TypesResult:
+        """List all detectable secret types."""
+        response = self._request("GET", "/v1/types")
+        return TypesResult.model_validate(response.json())
+
+    def health(self) -> HealthResult:
+        """Check API health."""
+        response = self._request("GET", "/v1/health")
+        return HealthResult.model_validate(response.json())
+
+    def feedback(
+        self,
+        request_id: str,
+        finding_id: str,
+        feedback_type: str,
+        comment: Optional[str] = None,
+    ) -> FeedbackResult:
+        """Report a false positive or false negative."""
+        body = {
+            "request_id": request_id,
+            "finding_id": finding_id,
+            "feedback_type": feedback_type,
+        }
+        if comment is not None:
+            body["comment"] = comment
+        response = self._request("POST", "/v1/feedback", json=body)
+        return FeedbackResult.model_validate(response.json())

classifinder/_exceptions.py

@@ -0,0 +1,67 @@
+"""ClassiFinder SDK exception hierarchy."""
+
+from typing import Any, Optional
+
+
+class ClassiFinderError(Exception):
+    """Base exception for all ClassiFinder SDK errors."""
+
+    def __init__(self, message: str, status_code: Optional[int] = None) -> None:
+        self.message = message
+        self.status_code = status_code
+        super().__init__(message)
+
+
+class AuthenticationError(ClassiFinderError):
+    """401 — Invalid or missing API key."""
+
+    def __init__(self, message: str) -> None:
+        super().__init__(message, status_code=401)
+
+
+class RateLimitError(ClassiFinderError):
+    """429 — Rate limit exceeded."""
+
+    def __init__(self, message: str, retry_after: int = 0) -> None:
+        self.retry_after = retry_after
+        super().__init__(message, status_code=429)
+
+
+class InvalidRequestError(ClassiFinderError):
+    """400 — Bad request (malformed input, payload too large, etc.)."""
+
+    def __init__(self, message: str, code: str = "invalid_request") -> None:
+        self.code = code
+        super().__init__(message, status_code=400)
+
+
+class ForbiddenError(ClassiFinderError):
+    """403 — Feature not available on current tier."""
+
+    def __init__(self, message: str, code: str = "tier_limit_exceeded") -> None:
+        self.code = code
+        super().__init__(message, status_code=403)
+
+
+class ServerError(ClassiFinderError):
+    """500 — Unexpected server-side error."""
+
+    def __init__(self, message: str) -> None:
+        super().__init__(message, status_code=500)
+
+
+class APIConnectionError(ClassiFinderError):
+    """Network failure, timeout, or DNS resolution failure."""
+
+    def __init__(self, message: str) -> None:
+        super().__init__(message, status_code=None)
+
+
+class SecretsDetectedError(ClassiFinderError):
+    """Raised by ClassiFinderGuard in block mode when secrets are found."""
+
+    def __init__(self, message: str, findings_count: int, findings: Any, summary: Any) -> None:
+        self.findings_count = findings_count
+        self.findings = findings
+        self.summary = summary
+        super().__init__(message, status_code=None)

classifinder/_models.py

@@ -0,0 +1,88 @@
+"""Pydantic v2 response models for the ClassiFinder API."""
+
+from typing import List, Optional
+
+from pydantic import BaseModel, ConfigDict
+
+
+class _Base(BaseModel):
+    model_config = ConfigDict(extra="ignore")
+
+
+class Span(_Base):
+    start: int
+    end: int
+
+
+class SeveritySummary(_Base):
+    critical: int = 0
+    high: int = 0
+    medium: int = 0
+    low: int = 0
+
+
+class Finding(_Base):
+    id: str
+    type: str
+    type_name: str
+    provider: str
+    severity: str
+    confidence: float
+    value_preview: str
+    span: Span
+    context: Optional[str] = None
+    is_likely_test_value: bool
+    recommendation: str
+    matched_pattern: str
+
+
+class RedactFinding(_Base):
+    id: str
+    type: str
+    severity: str
+    confidence: float
+    span: Span
+    redacted_as: str
+
+
+class TypeInfo(_Base):
+    id: str
+    name: str
+    provider: str
+    severity: str
+    description: str
+    tags: List[str] = []
+
+
+class ScanResult(_Base):
+    request_id: str
+    scan_time_ms: int
+    findings_count: int
+    findings: List[Finding]
+    summary: SeveritySummary
+
+
+class RedactResult(_Base):
+    request_id: str
+    scan_time_ms: int
+    findings_count: int
+    redacted_text: str
+    findings: List[RedactFinding]
+    summary: SeveritySummary
+
+
+class TypesResult(_Base):
+    types_count: int
+    types: List[TypeInfo]
+
+
+class HealthResult(_Base):
+    status: str
+    version: str
+    patterns_loaded: int
+    uptime_seconds: int
+
+
+class FeedbackResult(_Base):
+    feedback_id: str
+    status: str

classifinder/integrations/langchain.py

@@ -0,0 +1,126 @@
+"""LangChain integration — ClassiFinderGuard Runnable."""
+
+from typing import Any, List, Optional
+
+from pydantic import ConfigDict, PrivateAttr
+
+try:
+    from langchain_core.runnables import RunnableSerializable
+except ImportError:
+    raise ImportError(
+        "langchain-core is required for the LangChain integration. "
+        "Install it with: pip install classifinder[langchain]"
+    )
+
+from .._client import ClassiFinder
+from .._async_client import AsyncClassiFinder
+from .._exceptions import SecretsDetectedError
+from .._models import ScanResult
+
+
+class ClassiFinderGuard(RunnableSerializable[str, str]):
+    """A LangChain Runnable that scans/redacts secrets from text.
+
+    In redact mode (default), secrets are replaced and the clean text is
+    passed downstream. In block mode, an exception is raised if secrets
+    are found.
+    """
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    api_key: Optional[str] = None
+    mode: str = "redact"
+    redaction_style: str = "label"
+    types: List[str] = ["all"]
+    min_confidence: float = 0.5
+    base_url: str = "https://api.classifinder.tech"
+    max_retries: int = 2
+    timeout: float = 30.0
+
+    # Lazy-initialized clients (private attrs)
+    _sync_client: Optional[ClassiFinder] = PrivateAttr(default=None)
+    _async_client: Optional[AsyncClassiFinder] = PrivateAttr(default=None)
+
+    def _get_sync_client(self) -> ClassiFinder:
+        if self._sync_client is None:
+            self._sync_client = ClassiFinder(
+                api_key=self.api_key,
+                base_url=self.base_url,
+                max_retries=self.max_retries,
+                timeout=self.timeout,
+            )
+        return self._sync_client
+
+    def _get_async_client(self) -> AsyncClassiFinder:
+        if self._async_client is None:
+            self._async_client = AsyncClassiFinder(
+                api_key=self.api_key,
+                base_url=self.base_url,
+                max_retries=self.max_retries,
+                timeout=self.timeout,
+            )
+        return self._async_client
+
+    def _coerce_input(self, input: Any) -> str:
+        """Convert input to string, handling PromptValue objects."""
+        if isinstance(input, str):
+            return input
+        if hasattr(input, "to_string"):
+            return input.to_string()
+        return str(input)
+
+    def invoke(self, input: Any, config: Any = None, **kwargs) -> str:
+        """Sync: scan/redact text and return result."""
+        text = self._coerce_input(input)
+        client = self._get_sync_client()
+
+        if self.mode == "block":
+            result = client.scan(
+                text=text,
+                types=self.types,
+                min_confidence=self.min_confidence,
+            )
+            if result.findings_count > 0:
+                raise SecretsDetectedError(
+                    message=f"Found {result.findings_count} secret(s) in input text.",
+                    findings_count=result.findings_count,
+                    findings=result.findings,
+                    summary=result.summary,
+                )
+            return text
+        else:
+            result = client.redact(
+                text=text,
+                types=self.types,
+                min_confidence=self.min_confidence,
+                redaction_style=self.redaction_style,
+            )
+            return result.redacted_text
+
+    async def ainvoke(self, input: Any, config: Any = None, **kwargs) -> str:
+        """Async: scan/redact text and return result."""
+        text = self._coerce_input(input)
+        client = self._get_async_client()
+
+        if self.mode == "block":
+            result = await client.scan(
+                text=text,
+                types=self.types,
+                min_confidence=self.min_confidence,
+            )
+            if result.findings_count > 0:
+                raise SecretsDetectedError(
+                    message=f"Found {result.findings_count} secret(s) in input text.",
+                    findings_count=result.findings_count,
+                    findings=result.findings,
+                    summary=result.summary,
+                )
+            return text
+        else:
+            result = await client.redact(
+                text=text,
+                types=self.types,
+                min_confidence=self.min_confidence,
+                redaction_style=self.redaction_style,
+            )
+            return result.redacted_text

classifinder-0.1.0.dist-info/METADATA

@@ -0,0 +1,116 @@
+Metadata-Version: 2.4
+Name: classifinder
+Version: 0.1.0
+Summary: Python SDK for the ClassiFinder secret detection API
+License: MIT
+License-File: LICENSE
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: pydantic>=2.7.0
+Provides-Extra: dev
+Requires-Dist: pytest-asyncio>=0.24.0; extra == 'dev'
+Requires-Dist: pytest>=8.0.0; extra == 'dev'
+Requires-Dist: respx>=0.22.0; extra == 'dev'
+Provides-Extra: langchain
+Requires-Dist: langchain-core>=0.3.0; extra == 'langchain'
+Description-Content-Type: text/markdown
+
+# ClassiFinder
+
+Python SDK for the ClassiFinder secret detection API.
+
+Scan text for leaked secrets and credentials, get structured findings, and redact
+sensitive values -- all in a few lines of Python.
+
+## Installation
+
+```bash
+pip install classifinder
+```
+
+## Quick Start
+
+```python
+from classifinder import ClassiFinder
+
+client = ClassiFinder(api_key="ss_live_...")
+# or set the CLASSIFINDER_API_KEY environment variable
+
+result = client.scan("My AWS key is AKIAIOSFODNN7EXAMPLE")
+
+for finding in result.findings:
+    print(f"{finding.type_name} (severity={finding.severity}, confidence={finding.confidence})")
+    print(f"  Preview: {finding.value_preview}")
+```
+
+## Redact Secrets
+
+The `/v1/redact` endpoint replaces secrets in-place so you can safely pass text
+downstream to LLMs or logging systems.
+
+```python
+result = client.redact("DB password is SuperSecret123!")
+
+print(result.redacted_text)
+# "DB password is [DATABASE_PASSWORD]!"
+
+print(f"Redacted {result.findings_count} secret(s)")
+```
+
+## Async Support
+
+```python
+from classifinder import AsyncClassiFinder
+
+async def main():
+    client = AsyncClassiFinder(api_key="ss_live_...")
+    result = await client.scan("AKIA...")
+    await client.close()
+```
+
+## LangChain Integration
+
+Guard your LLM chains against secret leakage.
+
+```bash
+pip install classifinder[langchain]
+```
+
+```python
+from classifinder.integrations.langchain import ClassiFinderGuard
+
+guard = ClassiFinderGuard(api_key="ss_live_...", mode="redact")
+
+# Use as a standalone runnable
+clean_text = guard.invoke("My token is ghp_abc123secret")
+
+# Chain with other LangChain runnables
+chain = guard | your_llm | output_parser
+```
+
+Set `mode="block"` to raise `SecretsDetectedError` instead of redacting.
+
+## Error Handling
+
+```python
+from classifinder import ClassiFinder, AuthenticationError, RateLimitError, ClassiFinderError
+
+client = ClassiFinder(api_key="ss_live_...")
+
+try:
+    result = client.scan("check this text")
+except AuthenticationError:
+    print("Invalid API key")
+except RateLimitError as e:
+    print(f"Rate limited. Retry after {e.retry_after}s")
+except ClassiFinderError as e:
+    print(f"API error ({e.status_code}): {e.message}")
+```
+
+## Documentation
+
+Full API documentation: [https://classifinder.tech](https://classifinder.tech)
+
+## License
+
+MIT

classifinder-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+classifinder/__init__.py,sha256=mq-nsQMqzGoe7msavDm45CXsgcAYX3_GFj4DusV8Lh8,991
+classifinder/_async_client.py,sha256=rZ_uiml-6Zl7g3G5Q0e08fq51Of0jgEoCsr9J0xyx8E,4454
+classifinder/_base.py,sha256=EN8i6gOUeeH2tYbKxDj71C7MLPrDhqyJ6fQI2cYb4po,2942
+classifinder/_client.py,sha256=aQv-WfrRtbxT4zuz0ZUc3Z3WaUCBsCivHmRgs7doQ9s,4302
+classifinder/_exceptions.py,sha256=cPfm9iN4g0LkPYX18L_x0q2XK4mzWjE9xlnotUDiBXA,2105
+classifinder/_models.py,sha256=lVQUrexCzEgPPvQVCxA_y5TAGwvpqWym0Gruq13xQXQ,1498
+classifinder/integrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+classifinder/integrations/langchain.py,sha256=4jvzg3DkrR0k_TjnZCUTdKjBjRjMSULjLbWoE_PB--Q,4443
+classifinder-0.1.0.dist-info/METADATA,sha256=JAs7T7Xl02vQ3e2iJ_Bdz45ddIwk1KFIhIs5CEOobtw,2824
+classifinder-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+classifinder-0.1.0.dist-info/licenses/LICENSE,sha256=wmUJj88M_IbU6tJEONwZc5pKPwJwbmWC8SgFcgoAgRs,1069
+classifinder-0.1.0.dist-info/RECORD,,

classifinder-0.1.0.dist-info/WHEEL

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

classifinder-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ClassiFinder
+
+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.