paive-agents 0.1.0__tar.gz

paive_agents-0.1.0/PKG-INFO

@@ -0,0 +1,81 @@
+Metadata-Version: 2.4
+Name: paive-agents
+Version: 0.1.0
+Summary: Official Python SDK for the Paive patent intelligence report API
+License: Proprietary
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.28
+Requires-Dist: httpx>=0.24
+
+# paive-agents
+
+Official Python SDK for the Paive patent intelligence report API.
+
+## Install
+
+```bash
+pip install paive-agents
+```
+
+## Before publishing publicly
+
+`src/paive_agents/client.py` currently defaults to a staging server:
+
+```python
+DEFAULT_BASE_URL = "http://34.29.194.252:8000"
+```
+
+This is a working staging link (plain HTTP, IP-based). Before publishing this package
+anywhere public (PyPI, external customers), swap this for your real production domain
+over HTTPS. Until then, this default is fine for internal testing.
+
+## Sync usage
+
+```python
+from paive_agents import Client
+
+client = Client(api_key="YOUR_API_KEY")
+
+report = client.generate_report(
+    patent_id="US12093418B2",
+    tech_sector="Biotech / Therapeutics",
+    clp_factors=["Application Effect", "Benchmarking Data"],
+    market_factors=["Application Effect"],
+    licensing_factors=["Application Effect"],
+)
+
+print(report.pdf_file)
+```
+
+## Async usage
+
+```python
+from paive_agents import AsyncClient
+
+client = AsyncClient(api_key="YOUR_API_KEY")
+report = await client.generate_report(patent_id="US12093418B2")
+```
+
+## PDF upload instead of patent_id
+
+```python
+report = client.generate_report(pdf_path="/path/to/patent.pdf")
+```
+
+## Errors
+
+All errors subclass `paive_agents.PaiveError` and carry `.status_code` and `.response_body`:
+
+- `AuthenticationError` — invalid/missing API key (401)
+- `PermissionDeniedError` — user lacks permission (403)
+- `InvalidRequestError` — bad request (400/404)
+- `RateLimitError` — usage limit exceeded (429)
+- `ServerError` — server-side failure (500+)
+- `APIConnectionError` — network/connection failure
+
+## What this SDK does NOT change
+
+This package only talks to the existing `/api/keys/generate_report` endpoint over HTTP,
+using the same field names and the same `X-API-Key` auth your Django backend already expects.
+No backend files were modified to build this SDK.

paive_agents-0.1.0/README.md

@@ -0,0 +1,71 @@
+# paive-agents
+
+Official Python SDK for the Paive patent intelligence report API.
+
+## Install
+
+```bash
+pip install paive-agents
+```
+
+## Before publishing publicly
+
+`src/paive_agents/client.py` currently defaults to a staging server:
+
+```python
+DEFAULT_BASE_URL = "http://34.29.194.252:8000"
+```
+
+This is a working staging link (plain HTTP, IP-based). Before publishing this package
+anywhere public (PyPI, external customers), swap this for your real production domain
+over HTTPS. Until then, this default is fine for internal testing.
+
+## Sync usage
+
+```python
+from paive_agents import Client
+
+client = Client(api_key="YOUR_API_KEY")
+
+report = client.generate_report(
+    patent_id="US12093418B2",
+    tech_sector="Biotech / Therapeutics",
+    clp_factors=["Application Effect", "Benchmarking Data"],
+    market_factors=["Application Effect"],
+    licensing_factors=["Application Effect"],
+)
+
+print(report.pdf_file)
+```
+
+## Async usage
+
+```python
+from paive_agents import AsyncClient
+
+client = AsyncClient(api_key="YOUR_API_KEY")
+report = await client.generate_report(patent_id="US12093418B2")
+```
+
+## PDF upload instead of patent_id
+
+```python
+report = client.generate_report(pdf_path="/path/to/patent.pdf")
+```
+
+## Errors
+
+All errors subclass `paive_agents.PaiveError` and carry `.status_code` and `.response_body`:
+
+- `AuthenticationError` — invalid/missing API key (401)
+- `PermissionDeniedError` — user lacks permission (403)
+- `InvalidRequestError` — bad request (400/404)
+- `RateLimitError` — usage limit exceeded (429)
+- `ServerError` — server-side failure (500+)
+- `APIConnectionError` — network/connection failure
+
+## What this SDK does NOT change
+
+This package only talks to the existing `/api/keys/generate_report` endpoint over HTTP,
+using the same field names and the same `X-API-Key` auth your Django backend already expects.
+No backend files were modified to build this SDK.

paive_agents-0.1.0/pyproject.toml

@@ -0,0 +1,18 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "paive-agents"
+version = "0.1.0"
+description = "Official Python SDK for the Paive patent intelligence report API"
+readme = "README.md"
+requires-python = ">=3.8"
+license = { text = "Proprietary" }
+dependencies = [
+    "requests>=2.28",
+    "httpx>=0.24",
+]
+
+[tool.setuptools.packages.find]
+where = ["src"]

paive_agents-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

paive_agents-0.1.0/src/paive_agents/__init__.py

@@ -0,0 +1,28 @@
+from .client import Client, DEFAULT_BASE_URL
+from .async_client import AsyncClient
+from .models import Report
+from .exceptions import (
+    PaiveError,
+    AuthenticationError,
+    PermissionDeniedError,
+    InvalidRequestError,
+    RateLimitError,
+    ServerError,
+    APIConnectionError,
+)
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "Client",
+    "AsyncClient",
+    "Report",
+    "DEFAULT_BASE_URL",
+    "PaiveError",
+    "AuthenticationError",
+    "PermissionDeniedError",
+    "InvalidRequestError",
+    "RateLimitError",
+    "ServerError",
+    "APIConnectionError",
+]

paive_agents-0.1.0/src/paive_agents/_payload.py

@@ -0,0 +1,61 @@
+LIST_FIELDS = (
+    "revenue_types",
+    "funding_sources",
+    "suspicion_triggers",
+    "clp_factors",
+    "market_factors",
+    "licensing_factors",
+)
+
+SCALAR_FIELDS = (
+    "patent_id",
+    "name",
+    "email",
+    "company",
+    "patent_numbers",
+    "patent_type",
+    "role",
+    "trl_level",
+    "prototype_exists",
+    "commercialization_focus",
+    "revenue_status",
+    "traction_type",
+    "customer_discovery",
+    "pilots_trials",
+    "industry_interest",
+    "rpp_stage",
+    "rpp_deal",
+    "capital_raised",
+    "competing_technologies",
+    "primary_advantage",
+    "infringement_suspected",
+    "primary_objective",
+    "timeline_sensitivity",
+    "report_type",
+    "tech_sector",
+    "website",
+    "invention_disclosure",
+)
+
+
+def build_form_fields(input_type, api_key, **kwargs):
+    fields = []
+    fields.append(("input_type", input_type))
+    fields.append(("api_key", api_key))
+
+    for name in SCALAR_FIELDS:
+        value = kwargs.get(name)
+        if value is None:
+            continue
+        fields.append((name, str(value)))
+
+    for name in LIST_FIELDS:
+        values = kwargs.get(name)
+        if not values:
+            continue
+        if isinstance(values, (str, bytes)):
+            values = [values]
+        for item in values:
+            fields.append((name, str(item)))
+
+    return fields

paive_agents-0.1.0/src/paive_agents/async_client.py

@@ -0,0 +1,75 @@
+import httpx
+
+from ._payload import build_form_fields
+from .exceptions import raise_for_status, APIConnectionError
+from .models import Report
+from .client import DEFAULT_BASE_URL, GENERATE_REPORT_PATH
+
+
+class AsyncClient:
+    def __init__(self, api_key, base_url=None, timeout=60):
+        if not api_key:
+            raise ValueError("api_key is required")
+        self.api_key = api_key
+        self.base_url = (base_url or DEFAULT_BASE_URL).rstrip("/")
+        self.timeout = timeout
+
+    async def generate_report(
+        self,
+        patent_id=None,
+        pdf_path=None,
+        report_type="brief_IP_decision_support_intelligence",
+        tech_sector=None,
+        clp_factors=None,
+        market_factors=None,
+        licensing_factors=None,
+        revenue_types=None,
+        funding_sources=None,
+        suspicion_triggers=None,
+        **kwargs,
+    ):
+        if bool(patent_id) == bool(pdf_path):
+            raise ValueError("Provide exactly one of patent_id or pdf_path")
+
+        input_type = "patent_id" if patent_id else "pdf"
+
+        fields = build_form_fields(
+            input_type=input_type,
+            api_key=self.api_key,
+            patent_id=patent_id,
+            report_type=report_type,
+            tech_sector=tech_sector,
+            clp_factors=clp_factors,
+            market_factors=market_factors,
+            licensing_factors=licensing_factors,
+            revenue_types=revenue_types,
+            funding_sources=funding_sources,
+            suspicion_triggers=suspicion_triggers,
+            **kwargs,
+        )
+
+        url = self.base_url + GENERATE_REPORT_PATH
+        headers = {"X-API-Key": self.api_key}
+
+        files = None
+        file_bytes = None
+        if pdf_path:
+            with open(pdf_path, "rb") as f:
+                file_bytes = f.read()
+            files = {"pdf_file": (pdf_path.split("/")[-1], file_bytes, "application/pdf")}
+
+        async with httpx.AsyncClient(timeout=self.timeout) as client:
+            try:
+                response = await client.post(url, headers=headers, data=fields, files=files)
+            except httpx.HTTPError as exc:
+                raise APIConnectionError(f"Failed to reach {url}: {exc}") from exc
+
+        try:
+            body = response.json()
+        except ValueError:
+            body = {"error": response.text}
+
+        if response.status_code >= 400:
+            raise_for_status(response.status_code, body)
+
+        return Report.from_response(body)

paive_agents-0.1.0/src/paive_agents/client.py

@@ -0,0 +1,85 @@
+import requests
+
+from ._payload import build_form_fields
+from .exceptions import raise_for_status, APIConnectionError
+from .models import Report
+
+DEFAULT_BASE_URL = "http://34.29.194.252:8000"
+GENERATE_REPORT_PATH = "/api/keys/generate_report"
+
+
+class Client:
+    def __init__(self, api_key, base_url=None, timeout=60):
+        if not api_key:
+            raise ValueError("api_key is required")
+        self.api_key = api_key
+        self.base_url = (base_url or DEFAULT_BASE_URL).rstrip("/")
+        self.timeout = timeout
+
+    def generate_report(
+        self,
+        patent_id=None,
+        pdf_path=None,
+        report_type="brief_IP_decision_support_intelligence",
+        tech_sector=None,
+        clp_factors=None,
+        market_factors=None,
+        licensing_factors=None,
+        revenue_types=None,
+        funding_sources=None,
+        suspicion_triggers=None,
+        **kwargs,
+    ):
+        if bool(patent_id) == bool(pdf_path):
+            raise ValueError("Provide exactly one of patent_id or pdf_path")
+
+        input_type = "patent_id" if patent_id else "pdf"
+
+        fields = build_form_fields(
+            input_type=input_type,
+            api_key=self.api_key,
+            patent_id=patent_id,
+            report_type=report_type,
+            tech_sector=tech_sector,
+            clp_factors=clp_factors,
+            market_factors=market_factors,
+            licensing_factors=licensing_factors,
+            revenue_types=revenue_types,
+            funding_sources=funding_sources,
+            suspicion_triggers=suspicion_triggers,
+            **kwargs,
+        )
+
+        url = self.base_url + GENERATE_REPORT_PATH
+        headers = {"X-API-Key": self.api_key}
+
+        files = None
+        opened_file = None
+        try:
+            if pdf_path:
+                opened_file = open(pdf_path, "rb")
+                files = {"pdf_file": (pdf_path.split("/")[-1], opened_file, "application/pdf")}
+
+            try:
+                response = requests.post(
+                    url,
+                    headers=headers,
+                    data=fields,
+                    files=files,
+                    timeout=self.timeout,
+                )
+            except requests.RequestException as exc:
+                raise APIConnectionError(f"Failed to reach {url}: {exc}") from exc
+        finally:
+            if opened_file:
+                opened_file.close()
+
+        try:
+            body = response.json()
+        except ValueError:
+            body = {"error": response.text}
+
+        if not response.ok:
+            raise_for_status(response.status_code, body)
+
+        return Report.from_response(body)

paive_agents-0.1.0/src/paive_agents/exceptions.py

@@ -0,0 +1,75 @@
+class PaiveError(Exception):
+    def __init__(self, message, status_code=None, response_body=None):
+        super().__init__(message)
+        self.message = message
+        self.status_code = status_code
+        self.response_body = response_body
+
+
+class AuthenticationError(PaiveError):
+    pass
+
+
+class PermissionDeniedError(PaiveError):
+    pass
+
+
+class InvalidRequestError(PaiveError):
+    pass
+
+
+class RateLimitError(PaiveError):
+    pass
+
+
+class ServerError(PaiveError):
+    pass
+
+
+class APIConnectionError(PaiveError):
+    pass
+
+
+def raise_for_status(status_code, response_body):
+    if status_code == 401:
+        raise AuthenticationError(
+            _extract_message(response_body, "Invalid or missing API key."),
+            status_code,
+            response_body,
+        )
+    if status_code == 403:
+        raise PermissionDeniedError(
+            _extract_message(response_body, "You do not have permission to perform this action."),
+            status_code,
+            response_body,
+        )
+    if status_code == 400:
+        raise InvalidRequestError(
+            _extract_message(response_body, "Invalid request."),
+            status_code,
+            response_body,
+        )
+    if status_code == 404:
+        raise InvalidRequestError(
+            _extract_message(response_body, "Resource not found."),
+            status_code,
+            response_body,
+        )
+    if status_code == 429:
+        raise RateLimitError(
+            _extract_message(response_body, "Usage limit exceeded."),
+            status_code,
+            response_body,
+        )
+    if status_code >= 500:
+        raise ServerError(
+            _extract_message(response_body, "Server error, please try again later."),
+            status_code,
+            response_body,
+        )
+
+
+def _extract_message(response_body, default):
+    if isinstance(response_body, dict):
+        return response_body.get("error") or response_body.get("message") or default
+    return default

paive_agents-0.1.0/src/paive_agents/models.py

@@ -0,0 +1,17 @@
+from dataclasses import dataclass, field
+from typing import Optional, Dict, Any
+
+
+@dataclass
+class Report:
+    pdf_file: Optional[str] = None
+    escalation_report: Optional[str] = None
+    raw: Dict[str, Any] = field(default_factory=dict)
+
+    @classmethod
+    def from_response(cls, data):
+        return cls(
+            pdf_file=data.get("pdf_file"),
+            escalation_report=data.get("escalation_report"),
+            raw=data,
+        )

paive_agents-0.1.0/src/paive_agents.egg-info/PKG-INFO

@@ -0,0 +1,81 @@
+Metadata-Version: 2.4
+Name: paive-agents
+Version: 0.1.0
+Summary: Official Python SDK for the Paive patent intelligence report API
+License: Proprietary
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.28
+Requires-Dist: httpx>=0.24
+
+# paive-agents
+
+Official Python SDK for the Paive patent intelligence report API.
+
+## Install
+
+```bash
+pip install paive-agents
+```
+
+## Before publishing publicly
+
+`src/paive_agents/client.py` currently defaults to a staging server:
+
+```python
+DEFAULT_BASE_URL = "http://34.29.194.252:8000"
+```
+
+This is a working staging link (plain HTTP, IP-based). Before publishing this package
+anywhere public (PyPI, external customers), swap this for your real production domain
+over HTTPS. Until then, this default is fine for internal testing.
+
+## Sync usage
+
+```python
+from paive_agents import Client
+
+client = Client(api_key="YOUR_API_KEY")
+
+report = client.generate_report(
+    patent_id="US12093418B2",
+    tech_sector="Biotech / Therapeutics",
+    clp_factors=["Application Effect", "Benchmarking Data"],
+    market_factors=["Application Effect"],
+    licensing_factors=["Application Effect"],
+)
+
+print(report.pdf_file)
+```
+
+## Async usage
+
+```python
+from paive_agents import AsyncClient
+
+client = AsyncClient(api_key="YOUR_API_KEY")
+report = await client.generate_report(patent_id="US12093418B2")
+```
+
+## PDF upload instead of patent_id
+
+```python
+report = client.generate_report(pdf_path="/path/to/patent.pdf")
+```
+
+## Errors
+
+All errors subclass `paive_agents.PaiveError` and carry `.status_code` and `.response_body`:
+
+- `AuthenticationError` — invalid/missing API key (401)
+- `PermissionDeniedError` — user lacks permission (403)
+- `InvalidRequestError` — bad request (400/404)
+- `RateLimitError` — usage limit exceeded (429)
+- `ServerError` — server-side failure (500+)
+- `APIConnectionError` — network/connection failure
+
+## What this SDK does NOT change
+
+This package only talks to the existing `/api/keys/generate_report` endpoint over HTTP,
+using the same field names and the same `X-API-Key` auth your Django backend already expects.
+No backend files were modified to build this SDK.

paive_agents-0.1.0/src/paive_agents.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+README.md
+pyproject.toml
+src/paive_agents/__init__.py
+src/paive_agents/_payload.py
+src/paive_agents/async_client.py
+src/paive_agents/client.py
+src/paive_agents/exceptions.py
+src/paive_agents/models.py
+src/paive_agents.egg-info/PKG-INFO
+src/paive_agents.egg-info/SOURCES.txt
+src/paive_agents.egg-info/dependency_links.txt
+src/paive_agents.egg-info/requires.txt
+src/paive_agents.egg-info/top_level.txt

paive_agents-0.1.0/src/paive_agents.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

paive_agents-0.1.0/src/paive_agents.egg-info/requires.txt

@@ -0,0 +1,2 @@
+requests>=2.28
+httpx>=0.24

paive_agents-0.1.0/src/paive_agents.egg-info/top_level.txt

@@ -0,0 +1 @@
+paive_agents