congress-py 0.1.0__py3-none-any.whl

congress_py/__init__.py

@@ -0,0 +1,8 @@
+"""Public package interface for congress_py."""
+
+__version__ = "0.1.0"
+
+from congress_py.client import CongressClient
+from congress_py.models import Bill, BillAction, BillSummary
+
+__all__ = ["Bill", "BillAction", "BillSummary", "CongressClient"]

congress_py/cli.py

@@ -0,0 +1,276 @@
+"""Command-line interface for congress_py."""
+
+from __future__ import annotations
+
+import json
+import os
+from dataclasses import asdict, is_dataclass
+from pathlib import Path
+from typing import Any, Optional
+
+import typer
+
+from congress_py.client import CongressClient
+from congress_py.exceptions import MissingAPIKeyError
+
+CONFIG_DIR = Path.home() / ".congress"
+CONFIG_FILE = CONFIG_DIR / "config.toml"
+MISSING_API_KEY_MESSAGE = (
+    "No Congress.gov API key found. Run congress configure or set CONGRESS_API_KEY."
+)
+
+app = typer.Typer(help="CLI for the Congress.gov API.")
+congress_app = typer.Typer(help="Congress session commands.")
+bills_app = typer.Typer(help="Bill commands.")
+
+
+def _to_jsonable(value: Any) -> Any:
+    if is_dataclass(value):
+        return _to_jsonable(asdict(value))
+    if hasattr(value, "_asdict"):
+        return _to_jsonable(value._asdict())
+    if isinstance(value, dict):
+        return {key: _to_jsonable(item) for key, item in value.items()}
+    if isinstance(value, (list, tuple)):
+        return [_to_jsonable(item) for item in value]
+    return value
+
+
+def _json_default(value: Any) -> Any:
+    converted = _to_jsonable(value)
+    if converted is not value:
+        return converted
+    raise TypeError(f"Object of type {type(value).__name__} is not JSON serializable")
+
+
+def _print_json(value: Any) -> None:
+    typer.echo(
+        json.dumps(_to_jsonable(value), default=_json_default, indent=2, sort_keys=True)
+    )
+
+
+def _parse_simple_auth_toml(content: str) -> Optional[str]:
+    in_auth_section = False
+
+    for raw_line in content.splitlines():
+        line = raw_line.strip()
+        if not line or line.startswith("#"):
+            continue
+        if line.startswith("[") and line.endswith("]"):
+            in_auth_section = line == "[auth]"
+            continue
+        if not in_auth_section or "=" not in line:
+            continue
+
+        key, value = line.split("=", 1)
+        if key.strip() != "api_key":
+            continue
+        value = value.strip()
+        if len(value) >= 2 and value[0] == value[-1] and value[0] in {'"', "'"}:
+            value = value[1:-1]
+        return value.strip() or None
+
+    return None
+
+
+def _load_config_api_key(config_file: Optional[Path] = None) -> Optional[str]:
+    if config_file is None:
+        config_file = CONFIG_FILE
+
+    if not config_file.exists():
+        return None
+
+    content = config_file.read_text(encoding="utf-8")
+    try:
+        import tomllib
+    except ModuleNotFoundError:
+        return _parse_simple_auth_toml(content)
+
+    data = tomllib.loads(content)
+    auth = data.get("auth", {})
+    api_key = auth.get("api_key")
+    if isinstance(api_key, str):
+        return api_key.strip() or None
+    return None
+
+
+def _resolve_api_key(explicit_api_key: Optional[str]) -> str:
+    if explicit_api_key:
+        return explicit_api_key
+
+    env_api_key = os.environ.get("CONGRESS_API_KEY")
+    if env_api_key:
+        return env_api_key
+
+    config_api_key = _load_config_api_key()
+    if config_api_key:
+        return config_api_key
+
+    raise MissingAPIKeyError(MISSING_API_KEY_MESSAGE)
+
+
+def _get_client(ctx: typer.Context) -> CongressClient:
+    explicit_api_key = None
+    if ctx.obj:
+        explicit_api_key = ctx.obj.get("api_key")
+
+    try:
+        return CongressClient(api_key=_resolve_api_key(explicit_api_key))
+    except MissingAPIKeyError:
+        typer.echo(MISSING_API_KEY_MESSAGE, err=True)
+        raise typer.Exit(1)
+
+
+def _toml_string(value: str) -> str:
+    return value.replace("\\", "\\\\").replace('"', '\\"')
+
+
+@app.callback()
+def main(
+    ctx: typer.Context,
+    api_key: Optional[str] = typer.Option(
+        None,
+        "--api-key",
+        help=(
+            "Congress.gov API key. Defaults to CONGRESS_API_KEY "
+            "or ~/.congress/config.toml."
+        ),
+    ),
+) -> None:
+    """Resolve global CLI options for all commands.
+
+    Args:
+        ctx: Typer context used to share resolved option values with commands.
+        api_key: Optional Congress.gov API key. If omitted, API commands fall
+            back to ``CONGRESS_API_KEY`` and then ``~/.congress/config.toml``.
+
+    """
+    ctx.obj = {"api_key": api_key}
+
+
+@app.command()
+def configure(
+    api_key: str = typer.Option(
+        ...,
+        "--api-key",
+        prompt=True,
+        hide_input=True,
+        help="Congress.gov API key to save locally.",
+    ),
+) -> None:
+    """Save a Congress.gov API key for future CLI commands.
+
+    Args:
+        api_key: Congress.gov API key to write to ``~/.congress/config.toml``.
+
+    """
+    CONFIG_DIR.mkdir(mode=0o700, parents=True, exist_ok=True)
+    content = f'[auth]\napi_key = "{_toml_string(api_key)}"\n'
+
+    fd = os.open(CONFIG_FILE, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)
+    with os.fdopen(fd, "w", encoding="utf-8") as config:
+        config.write(content)
+
+    try:
+        CONFIG_FILE.chmod(0o600)
+    except OSError:
+        pass
+
+    typer.echo("Configuration saved.")
+
+
+@congress_app.command("current")
+def congress_current(ctx: typer.Context) -> None:
+    """Return the current congressional session."""
+    client = _get_client(ctx)
+    _print_json(client.get_current_session())
+
+
+@congress_app.command("list")
+def congress_list(ctx: typer.Context) -> None:
+    """Return available congressional sessions."""
+    client = _get_client(ctx)
+    _print_json(client.get_congresses())
+
+
+@bills_app.command("list")
+def bills_list(
+    ctx: typer.Context,
+    session: Optional[int] = typer.Option(
+        None,
+        "--session",
+        help="Congress session number to pass to the existing SDK method.",
+    ),
+    limit: int = typer.Option(
+        20,
+        "--limit",
+        min=1,
+        help="Number of bills to request per API call.",
+    ),
+    offset: int = typer.Option(
+        0,
+        "--offset",
+        min=0,
+        help=(
+            "Starting offset for single-page mode. "
+            "Ignored when --pages is provided."
+        ),
+    ),
+    pages: Optional[int] = typer.Option(
+        None,
+        "--pages",
+        min=1,
+        help="Number of pages to fetch using the SDK iterator.",
+    ),
+) -> None:
+    """Return bills, optionally filtered by Congress session.
+
+    Args:
+        ctx: Typer context containing global CLI option values.
+        session: Optional Congress number used to filter bill results.
+        limit: Number of bills to request per API call.
+        offset: Starting offset for single-page results.
+        pages: Optional number of pages to fetch with the SDK iterator. When
+            provided, ``offset`` is ignored.
+
+    """
+    client = _get_client(ctx)
+    if pages is None:
+        bills = client.get_bills(session=session, limit=limit, offset=offset)
+    else:
+        bills = list(client.iter_bills(session=session, limit=limit, max_pages=pages))
+    _print_json(bills)
+
+
+@bills_app.command("get")
+def bills_get(ctx: typer.Context, congress: int, bill_type: str, number: int) -> None:
+    """Return one bill by congress, bill type, and number."""
+    client = _get_client(ctx)
+    _print_json(client.get_bill(congress, bill_type, number))
+
+
+@bills_app.command("actions")
+def bills_actions(
+    ctx: typer.Context, congress: int, bill_type: str, number: int
+) -> None:
+    """Return actions for one bill."""
+    client = _get_client(ctx)
+    _print_json(client.get_bill_actions(congress, bill_type, number))
+
+
+@bills_app.command("summaries")
+def bills_summaries(
+    ctx: typer.Context, congress: int, bill_type: str, number: int
+) -> None:
+    """Return summaries for one bill."""
+    client = _get_client(ctx)
+    _print_json(client.get_bill_summaries(congress, bill_type, number))
+
+
+app.add_typer(congress_app, name="congress")
+app.add_typer(bills_app, name="bills")
+
+
+def run() -> None:
+    """Run the Typer application."""
+    app()

congress_py/client.py

@@ -0,0 +1,211 @@
+"""Client for the Congress.gov API."""
+
+from collections import namedtuple
+
+import requests
+
+from congress_py.models import Bill, BillAction, BillSummary
+
+
+class CongressClient:
+    """Client for interacting with Congress API endpoints.
+    
+    Args:
+        api_key (str): API key provided by api.congress.gov.
+        session: Optional ``requests.Session``-compatible object used to make
+              HTTP requests. If omitted, a new ``requests.Session`` is created.
+              This is mainly useful for tests or for callers that need custom
+              session configuration.
+
+    Attributes:
+        api_key: Congress.gov API key used for requests.
+        base_url: Base URL for the Congress.gov API.
+        congress_url: Base URL for congress/session endpoints.
+        bill_url: Base URL for bill endpoints.
+        session: HTTP session used to make requests.
+
+    """
+
+    def __init__(self, api_key, session=None):
+        self.api_key = api_key
+        self.base_url = "https://api.congress.gov/v3"
+        self.congress_url = f"{self.base_url}/congress"
+        self.bill_url = f"{self.base_url}/bill"
+        self.session = session or requests.Session()
+
+    def _convert_name_to_session(self, congress_name):
+        """Convert the congress name, return the numeric Congress name string.
+        
+        Args:
+            congress_name (str): the numerical congressional session in string
+                format (ex. '3rd', '4th')
+        
+        Returns:
+            A string, congress_name, with the suffix removed.
+
+        """
+        suffixes = ["st", "nd", "rd", "th"]
+        congress_name = congress_name.replace(" Congress", "")
+
+        for suffix in suffixes:
+            if suffix in congress_name:
+                congress_name = congress_name.replace(suffix, "")
+        return congress_name
+
+    def _convert_congress_to_tuple(self, congress):
+        """Convert congressional session information into a named tuple.
+        
+        Args:
+            congress: Congress data dictionary from the Congress.gov API response.
+
+        Returns:
+            A named tuple containing the congress name, end year, and chambers.
+        
+        """
+        Session = namedtuple("Session", ["name", "endYear", "chambers"])
+        chambers = []
+
+        for session in congress["sessions"]:
+            if session["chamber"] not in chambers:
+                chambers.append(session["chamber"])
+
+        return Session(congress["name"], congress["endYear"], chambers)
+
+    def _get(self, url, params=None):
+        """Return decoded JSON for a Congress API endpoint.
+        
+        Args:
+            url: Full endpoint URL to request.
+            params: Optional query parameters to include with the request. The API
+                key is added automatically.
+
+        Returns:
+            Decoded JSON response as a dictionary.
+
+        Raises:
+            requests.HTTPError: If Congress.gov returns an unsuccessful HTTP status.
+            requests.JSONDecodeError: If the response body is not valid JSON.
+
+        """
+        request_params = {"api_key": self.api_key}
+        if params:
+            request_params.update(params)
+
+        response = self.session.get(url, params=request_params, timeout=10)
+        response.raise_for_status()
+        return response.json()
+
+    def get_current_session(self):
+        """Return the current congressional session.
+        
+        Returns:
+            A named tuple containing the fields ``name``, ``endYear``, and ``chambers``.
+        
+        """
+        data = self._get(f"{self.congress_url}/current")
+        congress = data.get("congress")
+        if congress is None:
+            congress = data["congresses"][0]
+        return self._convert_congress_to_tuple(congress)
+
+    def get_congresses(self):
+        """Return congressional session records.
+        
+        Returns:
+            list[dict]: The raw ``congresses`` list from the API response.
+
+        """
+        data = self._get(self.congress_url)
+        return data["congresses"]
+
+    def get_bill(self, congress: int, bill_type: str, number: int):
+        """Return a bill for a given congress, bill type, and number.
+        
+        Args:
+            congress (int): A Congress number, such as ``118``.
+            bill_type: Congress.gov bill type code, such as ``"hr"`` or ``"s"``.
+            number: Bill number within that congress and bill type.
+    
+        Returns:
+            Bill: A ``Bill`` model created from the API response's ``bill`` object.
+
+        """
+        url = f"{self.bill_url}/{congress}/{bill_type}/{number}"
+        data = self._get(url)
+        return Bill.from_api_dict(data["bill"])
+
+    def get_bill_actions(self, congress: int, bill_type: str, number: int):
+        """Return actions for a given bill.
+        
+        Args:
+            congress: Congress number, such as ``118``.
+            bill_type: Congress.gov bill type code, such as ``"hr"`` or ``"s"``.
+            number: Bill number within that congress and bill type.
+
+        Returns:
+            list[BillAction]: Actions parsed from the API response's ``actions`` list.
+
+        """
+        url = f"{self.bill_url}/{congress}/{bill_type}/{number}/actions"
+        data = self._get(url)
+        return [BillAction.from_api_dict(action) for action in data["actions"]]
+
+    def get_bill_summaries(self, congress: int, bill_type: str, number: int):
+        """Return summaries for a given bill.
+        
+        Args:
+            congress: Congress number, such as ``118``.
+            bill_type: Congress.gov bill type code, such as ``"hr"`` or ``"s"``.
+            number: Bill number within that congress and bill type.
+
+        Returns:
+            list[BillSummary]: Summaries parsed from the API response's ``summaries`` list.
+
+        """
+        url = f"{self.bill_url}/{congress}/{bill_type}/{number}/summaries"
+        data = self._get(url)
+        return [BillSummary.from_api_dict(summary) for summary in data["summaries"]]
+
+    def get_bills(self, session=None, limit: int = 20, offset: int = 0):
+        """Return a page of bills, optionally filtered by Congress number.
+        
+        Args:
+            session: Optional Congress number used to filter results, such as ``118``.
+            limit: Maximum number of bills to request from the API.
+            offset: Number of records to skip before returning results.
+
+        Returns:
+            list[Bill]: Bills parsed from the API response's ``bills`` list.
+
+        """
+        params = {"limit": limit, "offset": offset}
+        if session is not None:
+            params["session"] = session
+
+        data = self._get(self.bill_url, params=params)
+        return [Bill.from_api_dict(bill) for bill in data["bills"]]
+
+    def iter_bills(self, session=None, limit: int = 20, max_pages=None):
+        """Yield bills across pages until no bills are returned.
+        
+        Args:
+            session: Optional Congress number used to filter results, such as ``118``.
+            limit: Number of bills to request per API page.
+            max_pages: Optional maximum number of pages to fetch. If omitted, pages
+                are fetched until the API returns an empty ``bills`` list.
+
+        Yields:
+            Bill: Bills parsed from each API response's ``bills`` list.
+
+        """
+        offset = 0
+        pages_fetched = 0
+
+        while max_pages is None or pages_fetched < max_pages:
+            bills = self.get_bills(session=session, limit=limit, offset=offset)
+            if not bills:
+                break
+
+            yield from bills
+            pages_fetched += 1
+            offset += limit

congress_py/exceptions.py

@@ -0,0 +1,17 @@
+"""Project-specific exceptions for congress_py."""
+
+
+class CongressAPIError(Exception):
+    """Base exception for congress_py errors."""
+
+
+class CongressAuthError(CongressAPIError):
+    """Base exception for authentication-related errors."""
+
+
+class MissingAPIKeyError(CongressAuthError):
+    """Raised when no Congress.gov API key is available."""
+
+
+class InvalidAPIKeyError(CongressAuthError):
+    """Raised when Congress.gov rejects the provided API key."""

congress_py/models.py

@@ -0,0 +1,109 @@
+"""Data models for Congress API responses."""
+
+from dataclasses import dataclass
+from typing import Any, Dict, Optional
+
+
+@dataclass
+class Bill:
+    """Bill data returned by Congress.gov.
+
+    Attributes:
+        congress: Congress number, such as ``118``.
+        latest_action_date: Date of the latest recorded action.
+        latest_action_text: Description of the latest recorded action.
+        number: Bill number within its bill type.
+        origin_chamber: Chamber where the bill originated.
+        title: Official bill title.
+        bill_type: Congress.gov bill type code, such as ``"hr"`` or ``"s"``.
+        update_date: Date the bill record was last updated.
+        update_including_text: Whether the bill text was included in the latest update.
+        url: Optional Congress.gov API URL for the bill record.
+
+    """
+    congress: int
+    latest_action_date: str
+    latest_action_text: str
+    number: str
+    origin_chamber: str
+    title: str
+    bill_type: str
+    update_date: str
+    update_including_text: bool
+    url: Optional[str] = None
+
+    @classmethod
+    def from_api_dict(cls, bill_data):
+        """Create a Bill from an API response dictionary."""
+        return cls(
+            congress=bill_data["congress"],
+            latest_action_date=bill_data["latestAction"]["actionDate"],
+            latest_action_text=bill_data["latestAction"]["text"],
+            number=bill_data["number"],
+            origin_chamber=bill_data["originChamber"],
+            title=bill_data["title"],
+            bill_type=bill_data["type"],
+            update_date=bill_data["updateDate"],
+            update_including_text=bill_data["updateDateIncludingText"],
+            url=bill_data.get("url"),
+        )
+
+
+@dataclass
+class BillAction:
+    """Legislative action recorded for a bill.
+
+    Attributes:
+        action_date: Date the action occurred, if provided by the API.
+        text: Description of the action, if provided by the API.
+        action_type: Congress.gov action type value, if provided.
+        source_system: Source system metadata from Congress.gov, if provided.
+        url: Optional Congress.gov API URL for the action record.
+
+    """
+    action_date: Optional[str]
+    text: Optional[str]
+    action_type: Optional[str] = None
+    source_system: Optional[Dict[str, Any]] = None
+    url: Optional[str] = None
+
+    @classmethod
+    def from_api_dict(cls, action_data):
+        """Create a BillAction from an API response dictionary."""
+        return cls(
+            action_date=action_data.get("actionDate"),
+            text=action_data.get("text"),
+            action_type=action_data.get("type"),
+            source_system=action_data.get("sourceSystem"),
+            url=action_data.get("url"),
+        )
+
+
+@dataclass
+class BillSummary:
+    """Summary text available for a bill.
+
+    Attributes:
+        action_date: Date associated with the summary action, if provided.
+        text: Summary text, if provided by the API.
+        update_date: Date the summary record was last updated, if provided.
+        version_code: Congress.gov summary version code, if provided.
+        action_desc: Description of the action associated with the summary, if provided.
+
+    """
+    action_date: Optional[str]
+    text: Optional[str]
+    update_date: Optional[str] = None
+    version_code: Optional[str] = None
+    action_desc: Optional[str] = None
+
+    @classmethod
+    def from_api_dict(cls, summary_data):
+        """Create a BillSummary from an API response dictionary."""
+        return cls(
+            action_date=summary_data.get("actionDate"),
+            text=summary_data.get("text"),
+            update_date=summary_data.get("updateDate"),
+            version_code=summary_data.get("versionCode"),
+            action_desc=summary_data.get("actionDesc"),
+        )

congress_py-0.1.0.dist-info/METADATA

@@ -0,0 +1,79 @@
+Metadata-Version: 2.4
+Name: congress-py
+Version: 0.1.0
+Summary: A lightweight Python SDK for interacting with the United States Congress API.
+Author: Antonio Alaniz
+License: MIT
+Project-URL: Homepage, https://github.com/talaniz/congress.py
+Project-URL: Documentation, https://talaniz.github.io/congress.py/
+Project-URL: Repository, https://github.com/talaniz/congress.py
+Project-URL: Issues, https://github.com/talaniz/congress.py/issues
+Project-URL: Changelog, https://github.com/talaniz/congress.py/blob/main/docs/changelog.md
+Keywords: congress,api,legislative,government,sdk
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests<3,>=2.32.3
+Requires-Dist: typer<1,>=0.12.5
+Provides-Extra: dev
+Requires-Dist: codecov<3,>=2.1.13; extra == "dev"
+Requires-Dist: coverage<8,>=7.6.4; extra == "dev"
+Requires-Dist: pytest<9,>=8.3.3; extra == "dev"
+Requires-Dist: pytest-cov<7,>=6.0.0; extra == "dev"
+Requires-Dist: requests-mock<2,>=1.12.1; extra == "dev"
+Provides-Extra: docs
+Requires-Dist: mkdocs<2,>=1.6.1; extra == "docs"
+Requires-Dist: mkdocs-material<10,>=9.5.49; extra == "docs"
+Requires-Dist: mkdocstrings[python]<1,>=0.27.1; extra == "docs"
+Dynamic: license-file
+
+# congress_py
+
+![Tests](https://github.com/talaniz/congress.py/actions/workflows/python-package.yml/badge.svg)
+
+`congress_py` is an unofficial Python SDK and CLI for reading data from the
+Congress.gov API.
+
+This project is not affiliated with Congress.gov, the Library of Congress,
+Congress, or the U.S. government. It does not provide legal, legislative,
+lobbying, financial, compliance, or policy advice.
+
+## Installation
+
+```bash
+pip install congress-py
+```
+
+### Local Development
+
+```bash
+git clone https://github.com/talaniz/congress.py.git
+cd congress.py
+python3 -m venv .venv
+.venv/bin/python -m pip install -e .
+```
+
+You will need your own Congress.gov API key.
+
+## Documentation
+
+Full documentation is available at:
+
+https://talaniz.github.io/congress.py/
+
+The documentation site includes installation steps, API-key setup, SDK examples,
+CLI examples, API reference, contributing guidance, and the changelog.
+
+## License
+
+MIT

congress_py-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+congress_py/__init__.py,sha256=dDUrm_N3yR5IrGu3Jg6tETOFhrvQahcK0rl0olZk2Mw,246
+congress_py/cli.py,sha256=Bvs3eOvTZvjGa-ufNw3omHJ6utdAjsh4ZmWPxgqL164,7800
+congress_py/client.py,sha256=5qP725nRvoIMXrH2PWGDZgbPi-F94tYgxqu573E0SEA,7640
+congress_py/exceptions.py,sha256=_Hpf5pJhyMr_Lw2IWw-AoGAilf9IoK1xPjHpkvdtTpM,461
+congress_py/models.py,sha256=_VqM5eoVv_ZYr_I7kTztu_hYWQP1Kl0XQFPhir5n3uw,3813
+congress_py-0.1.0.dist-info/licenses/LICENSE,sha256=jglVJoTRQMqCiDv_hN-1ppc0L0Pyu8qFt4fk0zCQpjI,1071
+congress_py-0.1.0.dist-info/METADATA,sha256=q2XT782rKxKZEMFX8ZvMLyC3uoVF_BVsvq53DDnKEtw,2669
+congress_py-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+congress_py-0.1.0.dist-info/entry_points.txt,sha256=NrISWYsCMRO9bddsNUT6JuX6IxQlCHjSKhm4ntO8avw,49
+congress_py-0.1.0.dist-info/top_level.txt,sha256=13cg4YqsszHdNEffQ2LZ_HD2byJ9hEAO_sd-pj54aeI,12
+congress_py-0.1.0.dist-info/RECORD,,

congress_py-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

congress_py-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+congress = congress_py.cli:run

congress_py-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Antonio Alaniz
+
+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.

congress_py-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+congress_py