lex-api-mx-client 0.1.1__py3-none-any.whl

lex_api_mx/__init__.py

@@ -0,0 +1,4 @@
+from .client import LexApiClient, LexApiError
+
+__all__ = ["LexApiClient", "LexApiError"]
+__version__ = "0.1.1"

lex_api_mx/client.py

@@ -0,0 +1,193 @@
+from __future__ import annotations
+
+from datetime import date
+from typing import Any
+from urllib.parse import quote
+
+import httpx
+
+
+class LexApiError(RuntimeError):
+    def __init__(
+        self,
+        status_code: int,
+        message: str,
+        request_id: str | None = None,
+        body: Any = None,
+    ):
+        self.status_code = status_code
+        self.request_id = request_id
+        self.detail = message
+        self.body = body
+        suffix = f" request_id={request_id}" if request_id else ""
+        super().__init__(f"Lex API MX returned {status_code}: {message}{suffix}")
+
+
+class LexApiClient:
+    """Synchronous client for the stable Lex API MX integration surface."""
+
+    def __init__(
+        self,
+        *,
+        base_url: str,
+        api_key: str,
+        timeout: float = 30.0,
+        transport: httpx.BaseTransport | None = None,
+        user_agent: str | None = None,
+    ) -> None:
+        if not base_url.strip():
+            raise ValueError("base_url is required")
+        if not api_key.strip():
+            raise ValueError("api_key is required")
+        if user_agent is None:
+            from . import __version__  # importación tardía: el paquete importa este módulo
+
+            user_agent = f"lex-api-mx-python/{__version__}"
+        self._client = httpx.Client(
+            base_url=base_url.rstrip("/"),
+            timeout=timeout,
+            transport=transport,
+            headers={
+                "X-API-Key": api_key,
+                "Accept": "application/json",
+                "User-Agent": user_agent,
+            },
+        )
+
+    def __enter__(self) -> "LexApiClient":
+        return self
+
+    def __exit__(self, *_: object) -> None:
+        self.close()
+
+    def close(self) -> None:
+        self._client.close()
+
+    def health(self) -> dict[str, Any]:
+        return self._request("GET", "/health")
+
+    def resolve(
+        self,
+        *,
+        query: str,
+        norm: str | None = None,
+        jurisdiction: str = "federal",
+        as_of: date | str | None = None,
+        limit: int = 10,
+        idempotency_key: str | None = None,
+    ) -> dict[str, Any]:
+        payload: dict[str, Any] = {
+            "query": query,
+            "jurisdiction": jurisdiction,
+            "limit": limit,
+        }
+        if norm is not None:
+            payload["norm"] = norm
+        if as_of is not None:
+            payload["date"] = as_of.isoformat() if isinstance(as_of, date) else as_of
+        return self._request(
+            "POST",
+            "/api/v1/resolve",
+            json=payload,
+            idempotency_key=idempotency_key,
+        )
+
+    def map(
+        self,
+        *,
+        query: str,
+        jurisdiction: str | None = None,
+        as_of: date | str | None = None,
+        mode: str = "api",
+        idempotency_key: str | None = None,
+    ) -> dict[str, Any]:
+        payload: dict[str, Any] = {"query": query, "mode": mode}
+        if jurisdiction is not None:
+            payload["jurisdiction"] = jurisdiction
+        if as_of is not None:
+            payload["date"] = as_of.isoformat() if isinstance(as_of, date) else as_of
+        return self._request(
+            "POST",
+            "/api/v1/map",
+            json=payload,
+            idempotency_key=idempotency_key,
+        )
+
+    def search_articles(
+        self,
+        *,
+        query: str,
+        norm: str | None = None,
+        matter: str | None = None,
+        jurisdiction: str | None = None,
+        as_of: date | str | None = None,
+        limit: int = 20,
+    ) -> dict[str, Any]:
+        params: dict[str, Any] = {"q": query, "limit": limit}
+        if norm is not None:
+            params["norma"] = norm
+        if matter is not None:
+            params["materia"] = matter
+        if jurisdiction is not None:
+            params["jurisdiccion"] = jurisdiction
+        if as_of is not None:
+            params["fecha"] = as_of.isoformat() if isinstance(as_of, date) else as_of
+        return self._request("GET", "/api/v1/articulos/search", params=params)
+
+    def norm_structure(
+        self,
+        norm: str,
+        *,
+        as_of: date | str | None = None,
+        include_text: bool = False,
+    ) -> dict[str, Any]:
+        if not norm.strip():
+            raise ValueError("norm is required")
+        params: dict[str, Any] = {"include_text": str(include_text).lower()}
+        if as_of is not None:
+            params["fecha"] = as_of.isoformat() if isinstance(as_of, date) else as_of
+        return self._request(
+            "GET",
+            f"/api/v1/normas/{quote(norm.strip(), safe='')}/estructura",
+            params=params,
+        )
+
+    def _request(
+        self,
+        method: str,
+        path: str,
+        *,
+        json: dict[str, Any] | None = None,
+        params: dict[str, Any] | None = None,
+        idempotency_key: str | None = None,
+    ) -> dict[str, Any]:
+        headers = {"Idempotency-Key": idempotency_key} if idempotency_key else None
+        response = self._client.request(method, path, json=json, params=params, headers=headers)
+        if response.is_error:
+            body: Any = None
+            try:
+                body = response.json()
+                message = str(body.get("detail", body)) if isinstance(body, dict) else str(body)
+            except ValueError:
+                message = response.text or response.reason_phrase
+            raise LexApiError(
+                response.status_code,
+                message,
+                response.headers.get("X-Request-ID"),
+                body,
+            )
+        try:
+            value = response.json()
+        except ValueError as exc:
+            raise LexApiError(
+                response.status_code,
+                "response was not valid JSON",
+                response.headers.get("X-Request-ID"),
+            ) from exc
+        if not isinstance(value, dict):
+            raise LexApiError(
+                response.status_code,
+                "response JSON must be an object",
+                response.headers.get("X-Request-ID"),
+            )
+        return value

lex_api_mx_client-0.1.1.dist-info/METADATA

@@ -0,0 +1,63 @@
+Metadata-Version: 2.5
+Name: lex-api-mx-client
+Version: 0.1.1
+Summary: Cliente Python de Lex API MX: legislación federal mexicana vigente con fuente, checksum y vigencia
+Project-URL: Homepage, https://lexapi.mx
+Project-URL: Documentation, https://lexapi.mx/docs
+Project-URL: Repository, https://github.com/Julio-Patron/Lex-API-Mx
+Author-email: Lex API MX <admin@lexapi.mx>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: api,legal,legislacion,leyes,mexico,sdk
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Natural Language :: Spanish
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.11
+Requires-Dist: httpx>=0.28
+Description-Content-Type: text/markdown
+
+# Lex API MX — cliente Python
+
+Cliente mínimo de [Lex API MX](https://lexapi.mx) para consultar la legislación
+federal mexicana vigente. Cada respuesta trae la fuente oficial, el checksum
+SHA-256 del texto y su periodo de vigencia.
+
+```bash
+pip install lex-api-mx-client
+```
+
+```python
+from lex_api_mx import LexApiClient, LexApiError
+
+with LexApiClient(base_url="https://api.lexapi.mx", api_key="tu_clave") as lex:
+    paquete = lex.resolve(query="Artículo 47 LFT", as_of="2026-10-08")
+    articulos = lex.search_articles(query="aguinaldo", norm="lft", jurisdiction="federal")
+    arbol = lex.norm_structure("lft")
+```
+
+| Método | Endpoint |
+|---|---|
+| `resolve(query, norm=None, jurisdiction="federal", as_of=None, limit=10)` | `POST /api/v1/resolve` |
+| `search_articles(query, norm=None, matter=None, jurisdiction=None, as_of=None, limit=20)` | `GET /api/v1/articulos/search` |
+| `norm_structure(norm, as_of=None, include_text=False)` | `GET /api/v1/normas/{slug}/estructura` |
+| `map(query, jurisdiction=None, as_of=None)` | `POST /api/v1/map` (requiere el permiso `map:read`) |
+
+`resolve` y `map` aceptan `idempotency_key`: un reintento con la misma clave no
+se cobra dos veces. Los errores HTTP se lanzan como `LexApiError` con
+`status_code`, `detail`, `request_id` y `body`; `402` significa saldo agotado.
+
+Para obtener una clave, crea tu cuenta en
+[lexapi.mx/#cuenta](https://lexapi.mx/#cuenta). Referencia de la API:
+[lexapi.mx/docs](https://lexapi.mx/docs).
+
+Para usar Lex API MX desde Claude, Cursor u otro agente, instala el servidor MCP
+[`lex-api-mx-mcp`](https://pypi.org/project/lex-api-mx-mcp/).
+
+Código fuente: [github.com/Julio-Patron/Lex-API-Mx](https://github.com/Julio-Patron/Lex-API-Mx/tree/main/packages/lex-api-client).
+Licencia MIT.

lex_api_mx_client-0.1.1.dist-info/RECORD

@@ -0,0 +1,6 @@
+lex_api_mx/__init__.py,sha256=sKfo4DlpEAhqy6RJDJB3G64pskMnlmgIyfxx5-xx8HA,111
+lex_api_mx/client.py,sha256=ADgmKlE_XE4Q8mzoYfyNUOoX85ocnV3yBS41MVDXMpk,6084
+lex_api_mx_client-0.1.1.dist-info/METADATA,sha256=3jfZlnk11HbUZOLJ3JQnKhDjoZX2cNQrRHm_-bQIH_8,2757
+lex_api_mx_client-0.1.1.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+lex_api_mx_client-0.1.1.dist-info/licenses/LICENSE,sha256=PlLjYKAY2g9heAxRGS-jSHErrfin7_XElwcGIy1wZEg,1067
+lex_api_mx_client-0.1.1.dist-info/RECORD,,

lex_api_mx_client-0.1.1.dist-info/WHEEL

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

lex_api_mx_client-0.1.1.dist-info/licenses/LICENSE

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