permisapi-client 0.2.0__tar.gz → 0.4.0__tar.gz

{permisapi_client-0.2.0 → permisapi_client-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: permisapi-client
-Version: 0.2.0
+Version: 0.4.0
 Summary: Client Python officiel pour PermisAPI : permis de construire France en API REST.
 Project-URL: Homepage, https://permisapi.fr
 Project-URL: Documentation, https://permisapi.fr/docs

{permisapi_client-0.2.0 → permisapi_client-0.4.0}/permisapi_client/client.py

@@ -130,6 +130,68 @@ class _PermitsResource:
             params["max_distance"] = max_distance
         return self._c._get(f"/v1/permits/{num_pa}/dvf", params=params or None)
 
+    def score_mdb(self, num_pa: str) -> dict[str, Any]:
+        """GET /v1/permits/{num_pa}/score : Score Opportunité MDB v0.1.
+
+        Plans Pro et superieurs uniquement (402 si Free / Explorer).
+        Retourne {num_pa, permit_id, score (0-100), tier (low/medium/
+        high/premium), components (7 signaux ponderes), weights,
+        version, method, dvf_matches_used, density_class}.
+
+        Algo : heuristique ponderee qui combine type permit, surface,
+        DVF voisin €/m², activite dep, demandeur (SCI vs promoteur),
+        coherence DVF/permit, densite INSEE.
+        """
+        return self._c._get(f"/v1/permits/{num_pa}/score")
+
+    def export(
+        self,
+        *,
+        dep_code: str | None = None,
+        comm_code: str | None = None,
+        permit_type: str | None = None,
+        date_from: str | None = None,
+        date_to: str | None = None,
+        etat_pa: int | None = None,
+        max_rows: int | None = None,
+    ) -> bytes:
+        """GET /v1/permits/export : export streaming CSV bulk (Business+).
+
+        Plans Business et Enterprise uniquement (403 si plan inferieur).
+        Cap par defaut : 100k lignes Business, 1M Enterprise. Le user
+        peut reduire via `max_rows` mais pas augmenter.
+
+        Retourne le contenu CSV brut en bytes UTF-8 (header + rows). Pour
+        sauver dans un fichier :
+
+          csv_bytes = client.permits.export(dep_code="75")
+          with open("paris.csv", "wb") as f:
+              f.write(csv_bytes)
+
+        Pour les gros exports (>100 MB), prefere le streaming via
+        `client._http.stream("GET", "/v1/permits/export", params=...)`.
+        """
+        params: dict[str, Any] = {}
+        if dep_code is not None:
+            params["dep_code"] = dep_code
+        if comm_code is not None:
+            params["comm_code"] = comm_code
+        if permit_type is not None:
+            params["permit_type"] = permit_type
+        if date_from is not None:
+            params["date_from"] = date_from
+        if date_to is not None:
+            params["date_to"] = date_to
+        if etat_pa is not None:
+            params["etat_pa"] = etat_pa
+        if max_rows is not None:
+            params["max_rows"] = max_rows
+        # Sortie binaire (CSV) -> on contourne _get qui parse en JSON.
+        url = f"{self._c.base_url}/v1/permits/export"
+        resp = self._c._http.get(url, params=params or None)
+        _raise_for_status(resp)
+        return resp.content
+
 
 class _StatsResource:
     def __init__(self, client: PermisAPI) -> None:
@@ -357,6 +419,43 @@ class _AsyncPermitsResource:
             params["max_distance"] = max_distance
         return await self._c._get(f"/v1/permits/{num_pa}/dvf", params=params or None)
 
+    async def score_mdb(self, num_pa: str) -> dict[str, Any]:
+        """GET /v1/permits/{num_pa}/score : version async. Plans Pro+ only."""
+        return await self._c._get(f"/v1/permits/{num_pa}/score")
+
+    async def export(
+        self,
+        *,
+        dep_code: str | None = None,
+        comm_code: str | None = None,
+        permit_type: str | None = None,
+        date_from: str | None = None,
+        date_to: str | None = None,
+        etat_pa: int | None = None,
+        max_rows: int | None = None,
+    ) -> bytes:
+        """GET /v1/permits/export : version async. Plans Business+ only.
+        Voir _PermitsResource.export pour la doc complete des params."""
+        params: dict[str, Any] = {}
+        if dep_code is not None:
+            params["dep_code"] = dep_code
+        if comm_code is not None:
+            params["comm_code"] = comm_code
+        if permit_type is not None:
+            params["permit_type"] = permit_type
+        if date_from is not None:
+            params["date_from"] = date_from
+        if date_to is not None:
+            params["date_to"] = date_to
+        if etat_pa is not None:
+            params["etat_pa"] = etat_pa
+        if max_rows is not None:
+            params["max_rows"] = max_rows
+        url = f"{self._c.base_url}/v1/permits/export"
+        resp = await self._c._http.get(url, params=params or None)
+        _raise_for_status(resp)
+        return resp.content
+
 
 class _AsyncStatsResource:
     def __init__(self, client: AsyncPermisAPI) -> None:

{permisapi_client-0.2.0 → permisapi_client-0.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "permisapi-client"
-version = "0.2.0"
+version = "0.4.0"
 description = "Client Python officiel pour PermisAPI : permis de construire France en API REST."
 readme = "README.md"
 requires-python = ">=3.9"

{permisapi_client-0.2.0 → permisapi_client-0.4.0}/tests/test_client.py

@@ -245,6 +245,98 @@ async def test_async_permits_dvf() -> None:
     assert result["num_pa"] == "PC-DVF-A"
 
 
+# ---------------------------------------------------------------------------
+# Export bulk CSV (Business+)
+# ---------------------------------------------------------------------------
+
+
+@respx.mock
+def test_permits_export_returns_csv_bytes() -> None:
+    """client.permits.export() retourne le CSV brut en bytes."""
+    csv_body = (
+        b"num_pa,dep_code,comm_code,permit_type\n"
+        b"PC-1,75,75118,PC_LOGEMENT\n"
+        b"PC-2,75,75118,PC_LOCAUX\n"
+    )
+    respx.get(f"{BASE}/v1/permits/export").respond(
+        content=csv_body,
+        headers={"content-type": "text/csv"},
+    )
+    with PermisAPI(api_key="pk_test_abc") as client:
+        result = client.permits.export(dep_code="75")
+    assert isinstance(result, bytes)
+    assert b"PC-1,75" in result
+    assert result.startswith(b"num_pa,")
+
+
+@respx.mock
+def test_permits_export_passes_filters_as_query() -> None:
+    route = respx.get(f"{BASE}/v1/permits/export").respond(content=b"num_pa\n")
+    with PermisAPI(api_key="pk_test_abc") as client:
+        client.permits.export(
+            dep_code="75",
+            comm_code="75118",
+            permit_type="PC_LOGEMENT",
+            date_from="2024-01-01",
+            date_to="2024-12-31",
+            etat_pa=1,
+            max_rows=5000,
+        )
+    qs = dict(route.calls.last.request.url.params)
+    assert qs["dep_code"] == "75"
+    assert qs["comm_code"] == "75118"
+    assert qs["permit_type"] == "PC_LOGEMENT"
+    assert qs["date_from"] == "2024-01-01"
+    assert qs["max_rows"] == "5000"
+
+
+@respx.mock
+def test_permits_export_403_for_explorer_plan() -> None:
+    """Plan inferieur a Business -> 403 Forbidden remonte tel quel."""
+    respx.get(f"{BASE}/v1/permits/export").respond(
+        status_code=403,
+        json={"error": "forbidden", "detail": "Plan Business+ requis"},
+    )
+    with PermisAPI(api_key="pk_test_abc") as client:
+        with pytest.raises(Exception):
+            client.permits.export()
+
+
+@respx.mock
+def test_permits_score_mdb() -> None:
+    respx.get(f"{BASE}/v1/permits/PC-1/score").respond(
+        json={"num_pa": "PC-1", "score": 78, "tier": "high", "components": {}}
+    )
+    with PermisAPI(api_key="pk_test_abc") as client:
+        result = client.permits.score_mdb("PC-1")
+    assert result["score"] == 78
+    assert result["tier"] == "high"
+
+
+@pytest.mark.asyncio
+@respx.mock
+async def test_async_permits_score_mdb() -> None:
+    respx.get(f"{BASE}/v1/permits/PC-A/score").respond(
+        json={"num_pa": "PC-A", "score": 42, "tier": "medium"}
+    )
+    async with AsyncPermisAPI(api_key="pk_test_abc") as client:
+        result = await client.permits.score_mdb("PC-A")
+    assert result["score"] == 42
+
+
+@pytest.mark.asyncio
+@respx.mock
+async def test_async_permits_export() -> None:
+    csv_body = b"num_pa,dep_code\nPC-A,75\n"
+    respx.get(f"{BASE}/v1/permits/export").respond(
+        content=csv_body, headers={"content-type": "text/csv"},
+    )
+    async with AsyncPermisAPI(api_key="pk_test_abc") as client:
+        result = await client.permits.export(dep_code="75")
+    assert isinstance(result, bytes)
+    assert b"PC-A,75" in result
+
+
 def test_custom_base_url() -> None:
     client = PermisAPI(api_key="pk_test_abc", base_url="http://localhost:8000/")
     assert client.base_url == "http://localhost:8000"