monopigi 0.1.0__tar.gz

monopigi-0.1.0/PKG-INFO

@@ -0,0 +1,24 @@
+Metadata-Version: 2.4
+Name: monopigi
+Version: 0.1.0
+Summary: Python SDK and CLI for the Monopigi Greek Government Data API
+Keywords: greek,government,data,api,procurement,open-data
+Author: Monopigi
+Author-email: Monopigi <info@monopigi.com>
+License-Expression: MIT
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries
+Requires-Dist: httpx>=0.28
+Requires-Dist: pydantic>=2.0
+Requires-Dist: typer>=0.15
+Requires-Dist: rich>=13.0
+Requires-Dist: textual>=3.0
+Requires-Dist: polars>=1.0 ; extra == 'all'
+Requires-Dist: polars>=1.0 ; extra == 'df'
+Requires-Python: >=3.12
+Project-URL: Homepage, https://monopigi.com
+Provides-Extra: all
+Provides-Extra: df

monopigi-0.1.0/pyproject.toml

@@ -0,0 +1,36 @@
+[project]
+name = "monopigi"
+version = "0.1.0"
+description = "Python SDK and CLI for the Monopigi Greek Government Data API"
+requires-python = ">=3.12"
+license = "MIT"
+authors = [{name = "Monopigi", email = "info@monopigi.com"}]
+keywords = ["greek", "government", "data", "api", "procurement", "open-data"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Software Development :: Libraries",
+]
+dependencies = [
+    "httpx>=0.28",
+    "pydantic>=2.0",
+    "typer>=0.15",
+    "rich>=13.0",
+    "textual>=3.0",
+]
+
+[project.optional-dependencies]
+df = ["polars>=1.0"]
+all = ["polars>=1.0"]
+
+[project.scripts]
+monopigi = "monopigi.cli:app"
+
+[project.urls]
+Homepage = "https://monopigi.com"
+
+[build-system]
+requires = ["uv_build>=0.10.9,<0.11.0"]
+build-backend = "uv_build"

monopigi-0.1.0/src/monopigi/__init__.py

@@ -0,0 +1,23 @@
+"""Monopigi -- Python SDK for the Greek Government Data API."""
+
+from monopigi.client import AsyncMonopigiClient, MonopigiClient
+from monopigi.exceptions import AuthError, MonopigiError, NotFoundError, RateLimitError, TierError
+from monopigi.models import Country, Document, OutputFormat, QuotaInfo, Source, SourceStatus, Tier
+
+__version__ = "0.1.0"
+__all__ = [
+    "AsyncMonopigiClient",
+    "AuthError",
+    "Country",
+    "Document",
+    "MonopigiClient",
+    "MonopigiError",
+    "NotFoundError",
+    "OutputFormat",
+    "QuotaInfo",
+    "RateLimitError",
+    "Source",
+    "SourceStatus",
+    "Tier",
+    "TierError",
+]

monopigi-0.1.0/src/monopigi/browse.py

@@ -0,0 +1,74 @@
+"""Interactive document browser using Textual TUI."""
+
+from __future__ import annotations
+
+HAS_TEXTUAL = False
+
+try:
+    from textual.app import App, ComposeResult
+    from textual.binding import Binding
+    from textual.widgets import DataTable, Footer, Header, Input
+
+    HAS_TEXTUAL = True
+except ImportError:
+    pass
+
+
+def check_textual() -> None:
+    """Raise a helpful error if textual is not installed."""
+    if not HAS_TEXTUAL:
+        raise ImportError("Interactive browse requires 'textual'. Install with: pip install monopigi-sdk[fuzzy]")
+
+
+if HAS_TEXTUAL:
+    from typing import ClassVar
+
+    class DocumentBrowser(App):  # type: ignore[misc]
+        """Interactive TUI for browsing Monopigi documents."""
+
+        TITLE = "Monopigi Document Browser"
+        BINDINGS: ClassVar[list[Binding]] = [
+            Binding("q", "quit", "Quit"),
+            Binding("escape", "quit", "Quit"),
+        ]
+
+        def __init__(self, documents: list[dict], source: str = "") -> None:
+            super().__init__()
+            self._documents = documents
+            self._source = source
+
+        def compose(self) -> ComposeResult:
+            yield Header()
+            yield Input(placeholder="Type to filter...", id="filter")
+            yield DataTable()
+            yield Footer()
+
+        def on_mount(self) -> None:
+            table = self.query_one(DataTable)
+            table.add_columns("Source", "Title", "Date", "Score")
+            self._populate_table(table, "")
+
+        def on_input_changed(self, event: Input.Changed) -> None:
+            table = self.query_one(DataTable)
+            table.clear()
+            self._populate_table(table, event.value.lower())
+
+        def _populate_table(self, table: DataTable, filter_text: str) -> None:
+            for doc in self._documents:
+                title = doc.get("title") or "\u2014"
+                source_lower = (doc.get("source") or "").lower()
+                if filter_text and filter_text not in title.lower() and filter_text not in source_lower:
+                    continue
+                table.add_row(
+                    doc.get("source", "\u2014"),
+                    title[:80],
+                    doc.get("published_at") or "\u2014",
+                    f"{doc.get('quality_score', 0):.2f}" if doc.get("quality_score") else "\u2014",
+                )
+
+
+def browse_documents(documents: list[dict], source: str = "") -> None:
+    """Launch the interactive document browser."""
+    check_textual()
+    app = DocumentBrowser(documents, source)
+    app.run()

monopigi-0.1.0/src/monopigi/cache.py

@@ -0,0 +1,41 @@
+"""Simple disk-based response cache with TTL."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import time
+from pathlib import Path
+
+DEFAULT_CACHE_DIR = Path.home() / ".monopigi" / "cache"
+
+
+class DiskCache:
+    """Cache API responses to disk as JSON files with a time-to-live."""
+
+    def __init__(self, ttl: int, cache_dir: Path = DEFAULT_CACHE_DIR) -> None:
+        self.ttl = ttl
+        self.cache_dir = cache_dir
+        self.cache_dir.mkdir(parents=True, exist_ok=True)
+
+    def _key(self, method: str, url: str, params: str) -> str:
+        raw = f"{method}:{url}:{params}"
+        return hashlib.sha256(raw.encode()).hexdigest()
+
+    def get(self, method: str, url: str, params: str) -> str | None:
+        """Return cached body if present and not expired, else None."""
+        key = self._key(method, url, params)
+        path = self.cache_dir / f"{key}.json"
+        if not path.exists():
+            return None
+        data = json.loads(path.read_text())
+        if time.time() - data["ts"] > self.ttl:
+            path.unlink()
+            return None
+        return data["body"]
+
+    def set(self, method: str, url: str, params: str, body: str) -> None:
+        """Store a response body in the cache."""
+        key = self._key(method, url, params)
+        path = self.cache_dir / f"{key}.json"
+        path.write_text(json.dumps({"ts": time.time(), "body": body}))