condepe 0.1.0__py3-none-any.whl

condepe/__init__.py

@@ -0,0 +1,53 @@
+"""condepe — open data of the Pernambuco Observatory from Python.
+
+Municipal series of Pernambuco, Brazil, published by Condepe/Fidem (the State
+Agency for Planning and Research) in the Observatory of Pernambuco: population,
+economy, public finance, labour, education, health, security, transport and
+more, every source in the same long format.
+
+Data come from https://cf.pe.gov.br/observatorio/dados/atual/, with a mirror
+on Hugging Face as fallback, and are cached on disk per catalogue version.
+
+Quick start
+-----------
+>>> import condepe
+>>> condepe.condepe_catalog()                                   # doctest: +SKIP
+>>> condepe.condepe_series("sidra_populacao_estimada",
+...     "Populacao residente estimada", code="2611606")       # doctest: +SKIP
+"""
+
+from __future__ import annotations
+
+from ._client import (
+    CondepeError,
+    HttpError,
+    IntegrityError,
+    set_timeout,
+)
+from ._client import cache_dir as condepe_cache_dir
+from ._client import clear_cache as condepe_cache_clear
+from ._msg import set_verbose
+from .data import (
+    condepe_catalog,
+    condepe_data,
+    condepe_indicators,
+    condepe_localities,
+    condepe_series,
+)
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "CondepeError",
+    "HttpError",
+    "IntegrityError",
+    "condepe_cache_clear",
+    "condepe_cache_dir",
+    "condepe_catalog",
+    "condepe_data",
+    "condepe_indicators",
+    "condepe_localities",
+    "condepe_series",
+    "set_timeout",
+    "set_verbose",
+]

condepe/_client.py

@@ -0,0 +1,167 @@
+"""HTTP layer: the canonical Observatory endpoint, with the Hugging Face
+mirror as fallback, and a disk cache keyed by catalogue version.
+
+Both backends serve the *same relative paths* (``catalogo.json``,
+``<source>/<source>.parquet``, ``MANIFESTO.sha256``), so a file is always
+addressed by its path in the catalogue. The mirror exists for availability:
+the canonical server is a single machine in Pernambuco, and its network may
+one day restrict access from outside Brazil.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import shutil
+import time
+from pathlib import Path
+from typing import Any
+from urllib.parse import quote
+
+import requests
+from platformdirs import user_cache_dir
+
+from . import _msg
+
+CANONICAL_URL = "https://cf.pe.gov.br/observatorio/dados/atual"
+MIRROR_URL = "https://huggingface.co/datasets/mlkwy/observatorio-pernambuco/resolve/main"
+USER_AGENT = "condepe Python package (https://github.com/StrategicProjects/condepe-py)"
+
+_TIMEOUT = 60.0
+_CATALOG_MAX_AGE = 6 * 3600  # seconds a cached catalogue is trusted without asking
+_TRANSIENT = {429, 500, 502, 503, 504}
+
+
+class CondepeError(RuntimeError):
+    """Base class for errors raised by condepe."""
+
+
+class HttpError(CondepeError):
+    """Neither the canonical endpoint nor the mirror answered."""
+
+
+class IntegrityError(CondepeError):
+    """A downloaded file does not match the sha256 in the catalogue."""
+
+
+def set_timeout(seconds: float = 60.0) -> None:
+    """Set the timeout, in seconds, of each HTTP request."""
+    global _TIMEOUT
+    if not isinstance(seconds, (int, float)) or isinstance(seconds, bool) or seconds <= 0:
+        raise ValueError("`seconds` must be a positive number.")
+    _TIMEOUT = float(seconds)
+
+
+def base_urls() -> list[str]:
+    """Backends in the order they are tried: canonical, then mirror.
+
+    ``CONDEPE_URL`` and ``CONDEPE_MIRROR_URL`` override them (an empty
+    ``CONDEPE_MIRROR_URL`` disables the fallback).
+    """
+    canonical = os.environ.get("CONDEPE_URL", CANONICAL_URL).rstrip("/")
+    mirror = os.environ.get("CONDEPE_MIRROR_URL", MIRROR_URL).rstrip("/")
+    return [u for u in (canonical, mirror) if u]
+
+
+def cache_dir() -> Path:
+    """Directory of the disk cache (``CONDEPE_CACHE_DIR`` overrides it)."""
+    return Path(os.environ.get("CONDEPE_CACHE_DIR") or user_cache_dir("condepe"))
+
+
+def clear_cache() -> Path:
+    """Delete every cached file and return the cache directory."""
+    d = cache_dir()
+    if d.exists():
+        shutil.rmtree(d)
+        _msg.success(f"Cleared condepe cache at {d}.")
+    else:
+        _msg.inform(f"No condepe cache found at {d}.")
+    return d
+
+
+def _get(url: str) -> bytes:
+    """One GET with up to three tries on transient failures."""
+    last: Exception | None = None
+    for attempt in range(3):
+        try:
+            resp = requests.get(url, timeout=_TIMEOUT, headers={"User-Agent": USER_AGENT})
+        except requests.RequestException as exc:  # connection, DNS, timeout
+            last = exc
+        else:
+            if resp.status_code == 200:
+                return resp.content
+            last = HttpError(f"HTTP {resp.status_code} from {url}")
+            if resp.status_code not in _TRANSIENT:
+                break
+        if attempt < 2:
+            time.sleep(2**attempt)
+    raise HttpError(str(last))
+
+
+def fetch(path: str) -> bytes:
+    """Fetch a relative path from the first backend that answers."""
+    errors = []
+    for base in base_urls():
+        url = f"{base}/{quote(path)}"
+        try:
+            return _get(url)
+        except HttpError as exc:
+            errors.append(f"{base}: {exc}")
+            if base != base_urls()[-1]:
+                _msg.step("Canonical endpoint unavailable; trying the mirror.")
+    raise HttpError("Could not reach the Observatory data. " + "; ".join(errors))
+
+
+def catalog_json(refresh: bool = False) -> dict[str, Any]:
+    """The published catalogue, from the disk cache when recent enough."""
+    path = cache_dir() / "catalogo.json"
+    if not refresh and path.exists() and time.time() - path.stat().st_mtime < _CATALOG_MAX_AGE:
+        return json.loads(path.read_text(encoding="utf-8"))
+    try:
+        raw = fetch("catalogo.json")
+    except HttpError:
+        # A stale catalogue is better than none: the files it lists are
+        # immutable per version and stay valid in the cache.
+        if path.exists():
+            _msg.step("Using the cached catalogue; the Observatory could not be reached.")
+            return json.loads(path.read_text(encoding="utf-8"))
+        raise
+    data = json.loads(raw)
+    if "versao" not in data or "fontes" not in data:
+        raise CondepeError("Unexpected catalogue format (no `versao`/`fontes`).")
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_bytes(raw)
+    return data
+
+
+def cached_file(path: str, sha256: str, version: str, refresh: bool = False) -> Path:
+    """Path to a verified local copy of a catalogue file, downloading if needed."""
+    dest = cache_dir() / version / path
+    if not refresh and dest.exists() and _sha256(dest.read_bytes()) == sha256:
+        return dest
+    raw = fetch(path)
+    got = _sha256(raw)
+    if got != sha256:
+        raise IntegrityError(
+            f"{path}: sha256 {got[:12]}… differs from the catalogue ({sha256[:12]}…). "
+            "The publication may be in progress; try again in a few minutes."
+        )
+    dest.parent.mkdir(parents=True, exist_ok=True)
+    tmp = dest.with_suffix(dest.suffix + ".tmp")
+    tmp.write_bytes(raw)
+    tmp.replace(dest)
+    _prune_old_versions(version)
+    return dest
+
+
+def _prune_old_versions(keep: str) -> None:
+    """Drop cached files of other catalogue versions (they are superseded)."""
+    root = cache_dir()
+    for child in root.iterdir():
+        if child.is_dir() and child.name != keep:
+            shutil.rmtree(child, ignore_errors=True)
+
+
+def _sha256(raw: bytes) -> str:
+    return hashlib.sha256(raw).hexdigest()

condepe/_msg.py

@@ -0,0 +1,31 @@
+"""Lightweight console messages, mirroring the R package's cli alerts.
+
+Messages go to stderr and can be silenced with :func:`set_verbose`.
+"""
+
+from __future__ import annotations
+
+import sys
+
+_VERBOSE = True
+
+
+def set_verbose(verbose: bool) -> None:
+    """Enable or disable informational messages."""
+    global _VERBOSE
+    _VERBOSE = bool(verbose)
+
+
+def success(message: str) -> None:
+    if _VERBOSE:
+        print(f"✔ {message}", file=sys.stderr)
+
+
+def step(message: str) -> None:
+    if _VERBOSE:
+        print(f"ℹ {message}", file=sys.stderr)
+
+
+def inform(message: str) -> None:
+    if _VERBOSE:
+        print(message, file=sys.stderr)

condepe/data.py

@@ -0,0 +1,226 @@
+"""Public functions: catalogue, indicators, full sources, series, localities.
+
+Every source of the Observatory is published in the same long format (one
+observation per row, 15 columns). Column names are kept in Portuguese, as
+published, so results stay traceable to the official files.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Iterable
+from typing import Any
+
+import pandas as pd
+import pyarrow.parquet as pq
+
+from . import _client, _msg
+
+CITATION = (
+    "Condepe/Fidem, Observatório de Pernambuco — Base de Dados do Estado, "
+    "version {version}, https://cf.pe.gov.br/observatorio (CC BY 4.0)."
+)
+
+_CATALOG_COLUMNS = [
+    "id_fonte",
+    "eixo",
+    "tema",
+    "assunto",
+    "descricao",
+    "fonte_original",
+    "linhas",
+    "indicadores",
+    "localidades",
+    "ano_inicio",
+    "ano_fim",
+]
+
+
+def condepe_catalog(refresh: bool = False) -> pd.DataFrame:
+    """List the sources published by the Observatory.
+
+    Parameters
+    ----------
+    refresh:
+        Ignore the cached catalogue (trusted for 6 hours) and ask the server.
+
+    Returns
+    -------
+    pandas.DataFrame
+        One row per source (``id_fonte``) with axis, theme, description,
+        original publisher, number of rows, indicators and localities, and the
+        years covered. ``attrs["version"]`` holds the catalogue version.
+    """
+    cat = _client.catalog_json(refresh=refresh)
+    df = pd.DataFrame([{k: f.get(k) for k in _CATALOG_COLUMNS} for f in cat["fontes"]])
+    df.attrs["version"] = cat["versao"]
+    df.attrs["citation"] = CITATION.format(version=cat["versao"])
+    return df
+
+
+def _source_entry(source: str, cat: dict[str, Any]) -> dict[str, Any]:
+    for f in cat["fontes"]:
+        if f["id_fonte"] == source:
+            return f
+    raise ValueError(
+        f"Unknown source {source!r}. See condepe_catalog() for the {len(cat['fontes'])} available."
+    )
+
+
+def condepe_data(source: str, refresh: bool = False) -> pd.DataFrame:
+    """Download a whole source (all indicators, localities and periods).
+
+    The Parquet file is kept in the disk cache for the current catalogue
+    version and verified against the sha256 published in the catalogue.
+
+    Parameters
+    ----------
+    source:
+        Source id, e.g. ``"sidra_populacao_estimada"`` (see
+        :func:`condepe_catalog`).
+    refresh:
+        Download again even if a verified copy is cached.
+
+    Returns
+    -------
+    pandas.DataFrame
+        The 15 columns of the Observatory long format: ``cd_municipio_ibge``,
+        ``nm_municipio``, ``ano``, ``mes``, ``indicador``, ``indicador_base``,
+        ``valor``, ``unidade``, ``natureza``, ``id_fonte``, ``eixo``, ``tema``,
+        ``assunto``, ``fonte_original``, ``arquivo_origem``.
+    """
+    cat = _client.catalog_json(refresh=refresh)
+    entry = _source_entry(source, cat)
+    parquet = next((a for a in entry.get("arquivos", []) if a.get("formato") == "parquet"), None)
+    if parquet is None:
+        raise _client.CondepeError(f"Source {source!r} has no Parquet file in the catalogue.")
+    path = _client.cached_file(
+        parquet["caminho"], parquet["sha256"], cat["versao"], refresh=refresh
+    )
+    df = pq.read_table(path).to_pandas()
+    df.attrs["version"] = cat["versao"]
+    df.attrs["source"] = source
+    _msg.success(f"{source}: {len(df):,} observations (version {cat['versao']}).")
+    return df
+
+
+def condepe_indicators(source: str, refresh: bool = False) -> pd.DataFrame:
+    """List the indicators of a source, with unit, coverage and periodicity.
+
+    Parameters
+    ----------
+    source:
+        Source id (see :func:`condepe_catalog`).
+    refresh:
+        Download the source again even if a verified copy is cached.
+
+    Returns
+    -------
+    pandas.DataFrame
+        One row per ``indicador_base`` with ``unidade``, ``natureza``,
+        ``mensal`` (monthly series), number of observations and localities,
+        and first/last year.
+    """
+    df = condepe_data(source, refresh=refresh)
+    out = (
+        df.groupby("indicador_base", sort=True)
+        .agg(
+            unidade=("unidade", "first"),
+            natureza=("natureza", "first"),
+            mensal=("mes", lambda s: bool(s.notna().any())),
+            observacoes=("valor", "size"),
+            localidades=("cd_municipio_ibge", "nunique"),
+            ano_inicio=("ano", "min"),
+            ano_fim=("ano", "max"),
+        )
+        .reset_index()
+    )
+    out.attrs = dict(df.attrs)
+    return out
+
+
+def _as_list(x: str | Iterable[str] | None) -> list[str] | None:
+    if x is None:
+        return None
+    return [x] if isinstance(x, str) else [str(v) for v in x]
+
+
+def condepe_series(
+    source: str,
+    indicator: str | Iterable[str],
+    code: str | Iterable[str] | None = None,
+    years: int | Iterable[int] | None = None,
+    refresh: bool = False,
+) -> pd.DataFrame:
+    """Series of one or more indicators, optionally filtered by place and year.
+
+    Parameters
+    ----------
+    source:
+        Source id (see :func:`condepe_catalog`).
+    indicator:
+        One or more ``indicador_base`` values, exactly as listed by
+        :func:`condepe_indicators`.
+    code:
+        IBGE codes: 7 digits for municipalities, ``"26"`` for the State.
+        ``None`` keeps every locality.
+    years:
+        A year or a collection of years; ``None`` keeps all.
+
+    Returns
+    -------
+    pandas.DataFrame
+        The matching observations, sorted by locality, year and month.
+    """
+    df = condepe_data(source, refresh=refresh)
+    wanted = _as_list(indicator) or []
+    missing = sorted(set(wanted) - set(df["indicador_base"].unique()))
+    if missing:
+        raise ValueError(
+            f"Indicator(s) not in {source!r}: {missing}. See condepe_indicators({source!r})."
+        )
+    keep = df["indicador_base"].isin(wanted)
+    codes = _as_list(code)
+    if codes is not None:
+        keep &= df["cd_municipio_ibge"].isin(codes)
+    if years is not None:
+        ys = [years] if isinstance(years, int) else list(years)
+        keep &= df["ano"].isin(ys)
+    out = df[keep].sort_values(["cd_municipio_ibge", "ano", "mes"], na_position="first")
+    out = out.reset_index(drop=True)
+    out.attrs = dict(df.attrs)
+    if out.empty:
+        _msg.step("No observations match these filters.")
+    return out
+
+
+def condepe_localities(refresh: bool = False) -> pd.DataFrame:
+    """The 185 municipalities of Pernambuco and the State, with IBGE codes.
+
+    Taken from the population estimates source, which covers every
+    municipality (Fernando de Noronha included); the State (``"26"``) comes
+    first.
+
+    Parameters
+    ----------
+    refresh:
+        Download the source again even if a verified copy is cached.
+
+    Returns
+    -------
+    pandas.DataFrame
+        ``cd_municipio_ibge`` and ``nm_municipio``.
+    """
+    df = condepe_data("sidra_populacao_estimada", refresh=refresh)
+    out = (
+        df[["cd_municipio_ibge", "nm_municipio"]]
+        .drop_duplicates()
+        .sort_values("cd_municipio_ibge")
+        .reset_index(drop=True)
+    )
+    if not (out["cd_municipio_ibge"] == "26").any():
+        out = pd.concat(
+            [pd.DataFrame({"cd_municipio_ibge": ["26"], "nm_municipio": ["Pernambuco"]}), out],
+            ignore_index=True,
+        )
+    out.attrs = dict(df.attrs)
+    return out

condepe-0.1.0.dist-info/METADATA

@@ -0,0 +1,133 @@
+Metadata-Version: 2.5
+Name: condepe
+Version: 0.1.0
+Summary: Access the open data of the Pernambuco Observatory (Condepe/Fidem) from Python
+Project-URL: Homepage, https://strategicprojects.github.io/condepe-py/
+Project-URL: Data, https://cf.pe.gov.br/observatorio
+Project-URL: Repository, https://github.com/StrategicProjects/condepe-py
+Project-URL: Issues, https://github.com/StrategicProjects/condepe-py/issues
+Project-URL: Changelog, https://github.com/StrategicProjects/condepe-py/blob/main/NEWS.md
+Author-email: André Leite <leite@castlab.org>, Marcos Wasiliew <marcos.wasiliew@gmail.com>, Hugo Vasconcelos <hugo.vasconcelos@ufpe.br>, Carlos Amorim <carlos.agaf@ufpe.br>, Diogo Bezerra <diogo.bezerra@ufpe.br>, Júlia Nascimento Barreto <juliabarreto@gd.seplag.pe.gov.br>
+License: MIT License
+        
+        Copyright (c) 2026 condepe authors
+        
+        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.
+License-File: LICENSE
+Keywords: Brazil,Condepe/Fidem,Pernambuco,municipalities,open-data,pandas,statistics
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.10
+Requires-Dist: pandas>=1.3
+Requires-Dist: platformdirs>=3
+Requires-Dist: pyarrow>=10
+Requires-Dist: requests>=2.25
+Provides-Extra: dev
+Requires-Dist: build>=1.0; extra == 'dev'
+Requires-Dist: pytest>=7; extra == 'dev'
+Requires-Dist: responses>=0.23; extra == 'dev'
+Requires-Dist: ruff>=0.6; extra == 'dev'
+Provides-Extra: docs
+Requires-Dist: matplotlib>=3.5; extra == 'docs'
+Requires-Dist: mkdocs-material>=9.5; extra == 'docs'
+Requires-Dist: mkdocstrings[python]>=0.26; extra == 'docs'
+Provides-Extra: test
+Requires-Dist: pytest>=7; extra == 'test'
+Requires-Dist: responses>=0.23; extra == 'test'
+Description-Content-Type: text/markdown
+
+# condepe <img src="docs/assets/logo.svg" align="right" height="139" alt="condepe hex logo" />
+
+Python access to the open data of the **Observatório de Pernambuco**, published by
+[Condepe/Fidem](https://cf.pe.gov.br) (the Pernambuco State Agency for Planning and
+Research): municipal series on population, economy, public finance, labour,
+education, health, security, transport and environment for the 185
+municipalities of Pernambuco, Brazil.
+
+Every source is published in the same long format (one observation per row, 15
+columns), so one set of functions covers all of them.
+
+## Installation
+
+```bash
+pip install condepe
+# development version:
+pip install git+https://github.com/StrategicProjects/condepe-py
+```
+
+## Usage
+
+```python
+import condepe
+
+# Sources available (one row each), with the catalogue version
+cat = condepe.condepe_catalog()
+cat.attrs["version"]
+
+# Indicators of a source
+condepe.condepe_indicators("sidra_populacao_estimada")
+
+# A series: Recife (IBGE 2611606), 2020 onwards
+condepe.condepe_series(
+    "sidra_populacao_estimada",
+    "Populacao residente estimada",
+    code="2611606",
+    years=range(2020, 2027),
+)
+
+# A whole source, and the municipality list
+condepe.condepe_data("datasus_sinasc")
+condepe.condepe_localities()
+```
+
+Column names are kept in Portuguese, as published, so results stay traceable to
+the official files: `cd_municipio_ibge`, `nm_municipio`, `ano`, `mes`,
+`indicador`, `indicador_base`, `valor`, `unidade`, `natureza`, `id_fonte`,
+`eixo`, `tema`, `assunto`, `fonte_original`, `arquivo_origem`. Monthly series
+carry the period in `indicador` (`"… [MM/YYYY]"`) and `mes`; `indicador_base` is
+the label without it.
+
+## Where the data come from
+
+- **Canonical:** <https://cf.pe.gov.br/observatorio/dados/atual/>
+- **Mirror (fallback):** the Hugging Face dataset
+  [`mlkwy/observatorio-pernambuco`](https://huggingface.co/datasets/mlkwy/observatorio-pernambuco),
+  with the same relative paths.
+
+Files are cached on disk per catalogue version (`condepe_cache_dir()`) and
+checked against the sha256 published in the catalogue. The catalogue itself is
+trusted for 6 hours. Set `CONDEPE_URL`, `CONDEPE_MIRROR_URL` or
+`CONDEPE_CACHE_DIR` to override the defaults.
+
+Documentation: <https://strategicprojects.github.io/condepe-py/>.
+
+## Citation and license
+
+Data: Condepe/Fidem, *Observatório de Pernambuco — Base de Dados do Estado*,
+[CC BY 4.0](https://creativecommons.org/licenses/by/4.0/). The citation with the
+version in use is in `condepe_catalog().attrs["citation"]`.
+
+Code: MIT. To read or write *private* buckets on `s3.pe.gov.br` with an
+access key, see [`s3pe`](https://github.com/StrategicProjects/s3pe); `condepe`
+needs no key, since the Observatory open data are public. An R package with the same functions is
+[`condepe` for R](https://github.com/StrategicProjects/condepe-r).

condepe-0.1.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+condepe/__init__.py,sha256=h4l6WNPK8xVfeGTkC8sAg--Rsol-2Z7tBE02kpx7WH4,1466
+condepe/_client.py,sha256=Du8oILzWB7CE70gv2BVLhWtZeAfezdN11iJB-mWR5hA,5956
+condepe/_msg.py,sha256=C1jJiz_A72uWSw7Zf56Vf6mEkgc3kQxz6tQQjxsmEbA,648
+condepe/data.py,sha256=IEBGM701am-FAEQfbm1n7guaW8-BNs16Qr73SBto8v0,7292
+condepe-0.1.0.dist-info/METADATA,sha256=grWJGqyC1ew9uNXz0GPvUC2Rn1fgFRx_-y7su5b9Zko,5914
+condepe-0.1.0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+condepe-0.1.0.dist-info/licenses/LICENSE,sha256=I0Xb_g3ZGRlzoO6Ggc7XzutyHUVBtCa8SLtfQiltGdA,1072
+condepe-0.1.0.dist-info/RECORD,,

condepe-0.1.0.dist-info/WHEEL

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

condepe-0.1.0.dist-info/licenses/LICENSE

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