form4api 0.1.0__py3-none-any.whl

form4api/__init__.py

@@ -0,0 +1,30 @@
+from form4api._client import AsyncForm4ApiClient, Form4ApiClient
+from form4api._errors import AuthError, Form4ApiError, NotFoundError, PlanError, RateLimitError
+from form4api._types import (
+    Company,
+    Insider,
+    InsiderSignal,
+    Transaction,
+    WebhookCreated,
+    WebhookEvent,
+    WebhookSubscription,
+)
+from form4api._webhook_utils import verify_webhook
+
+__all__ = [
+    "Form4ApiClient",
+    "AsyncForm4ApiClient",
+    "Form4ApiError",
+    "AuthError",
+    "PlanError",
+    "NotFoundError",
+    "RateLimitError",
+    "Transaction",
+    "Insider",
+    "Company",
+    "InsiderSignal",
+    "WebhookCreated",
+    "WebhookEvent",
+    "WebhookSubscription",
+    "verify_webhook",
+]

form4api/_client.py

@@ -0,0 +1,219 @@
+from __future__ import annotations
+
+import asyncio
+import re
+import time
+from typing import Any, TypeVar
+
+import httpx
+
+from form4api._errors import AuthError, Form4ApiError, NotFoundError, PlanError, RateLimitError
+from form4api.resources._companies import CompaniesResource
+from form4api.resources._insiders import InsidersResource
+from form4api.resources._signals import SignalsResource
+from form4api.resources._transactions import TransactionsResource
+from form4api.resources._webhooks import WebhooksResource
+
+DEFAULT_BASE_URL = "https://api.form4api.com"
+_RETRY_DELAYS = [0.5, 1.0, 2.0]
+
+T = TypeVar("T")
+
+
+def _camel_to_snake(name: str) -> str:
+    s = re.sub(r"([A-Z]+)([A-Z][a-z])", r"\1_\2", name)
+    return re.sub(r"([a-z\d])([A-Z])", r"\1_\2", s).lower()
+
+
+def _normalise(obj: Any) -> Any:
+    if isinstance(obj, dict):
+        return {_camel_to_snake(k): _normalise(v) for k, v in obj.items()}
+    if isinstance(obj, list):
+        return [_normalise(i) for i in obj]
+    return obj
+
+
+class Form4ApiClient:
+    """Synchronous client for the Form4API."""
+
+    def __init__(
+        self,
+        api_key: str,
+        *,
+        base_url: str = DEFAULT_BASE_URL,
+        max_retries: int = 2,
+        timeout: float = 30.0,
+    ) -> None:
+        self._api_key = api_key
+        self._base_url = base_url.rstrip("/")
+        self._max_retries = max_retries
+        self._http = httpx.Client(
+            timeout=timeout,
+            headers={"X-Api-Key": api_key},
+        )
+        self.transactions = TransactionsResource(self)
+        self.insiders = InsidersResource(self)
+        self.companies = CompaniesResource(self)
+        self.signals = SignalsResource(self)
+        self.webhooks = WebhooksResource(self)
+
+    def __enter__(self) -> Form4ApiClient:
+        return self
+
+    def __exit__(self, *_: object) -> None:
+        self.close()
+
+    def close(self) -> None:
+        self._http.close()
+
+    def _request(self, method: str, path: str, **kwargs: Any) -> httpx.Response:
+        url = self._base_url + path
+        last_exc: Exception | None = None
+
+        for attempt in range(self._max_retries + 1):
+            if attempt > 0:
+                time.sleep(_RETRY_DELAYS[min(attempt - 1, len(_RETRY_DELAYS) - 1)])
+            try:
+                res = self._http.request(method, url, **kwargs)
+                if res.status_code < 500:
+                    return res
+                if attempt == self._max_retries:
+                    return res
+                last_exc = None
+            except httpx.TransportError as exc:
+                if attempt == self._max_retries:
+                    raise
+                last_exc = exc
+
+        raise last_exc  # type: ignore[misc]
+
+    def _get(self, path: str, params: dict[str, str] | None = None) -> Any:
+        res = self._request("GET", path, params=params)
+        return _normalise(self._parse(res))
+
+    def _post(self, path: str, body: Any = None) -> Any:
+        res = self._request("POST", path, json=body)
+        return _normalise(self._parse(res))
+
+    def _delete(self, path: str) -> None:
+        res = self._request("DELETE", path)
+        if not res.is_success and res.status_code != 204:
+            self._raise(res)
+
+    def _parse(self, res: httpx.Response) -> Any:
+        if res.is_success:
+            return res.json()
+        self._raise(res)
+
+    def _raise(self, res: httpx.Response) -> None:
+        try:
+            body = res.json()
+        except Exception:
+            body = {}
+        error = body.get("error", {}) if isinstance(body, dict) else {}
+        code = error.get("code") if isinstance(error, dict) else None
+        message = (error.get("message") if isinstance(error, dict) else None) or f"HTTP {res.status_code}"
+
+        if res.status_code == 401:
+            raise AuthError(message, code)
+        if res.status_code == 402:
+            raise PlanError(message, body.get("requiredPlan") if isinstance(body, dict) else None)
+        if res.status_code == 404:
+            raise NotFoundError(message, code)
+        if res.status_code == 429:
+            retry_after = res.headers.get("Retry-After")
+            raise RateLimitError(message, int(retry_after) if retry_after else None)
+        raise Form4ApiError(message, res.status_code, code)
+
+
+class AsyncForm4ApiClient:
+    """Async client for the Form4API."""
+
+    def __init__(
+        self,
+        api_key: str,
+        *,
+        base_url: str = DEFAULT_BASE_URL,
+        max_retries: int = 2,
+        timeout: float = 30.0,
+    ) -> None:
+        self._api_key = api_key
+        self._base_url = base_url.rstrip("/")
+        self._max_retries = max_retries
+        self._http = httpx.AsyncClient(
+            timeout=timeout,
+            headers={"X-Api-Key": api_key},
+        )
+        self.transactions = TransactionsResource(self)  # type: ignore[arg-type]
+        self.insiders = InsidersResource(self)  # type: ignore[arg-type]
+        self.companies = CompaniesResource(self)  # type: ignore[arg-type]
+        self.signals = SignalsResource(self)  # type: ignore[arg-type]
+        self.webhooks = WebhooksResource(self)  # type: ignore[arg-type]
+
+    async def __aenter__(self) -> AsyncForm4ApiClient:
+        return self
+
+    async def __aexit__(self, *_: object) -> None:
+        await self.close()
+
+    async def close(self) -> None:
+        await self._http.aclose()
+
+    async def _request(self, method: str, path: str, **kwargs: Any) -> httpx.Response:
+        url = self._base_url + path
+        last_exc: Exception | None = None
+
+        for attempt in range(self._max_retries + 1):
+            if attempt > 0:
+                await asyncio.sleep(_RETRY_DELAYS[min(attempt - 1, len(_RETRY_DELAYS) - 1)])
+            try:
+                res = await self._http.request(method, url, **kwargs)
+                if res.status_code < 500:
+                    return res
+                if attempt == self._max_retries:
+                    return res
+                last_exc = None
+            except httpx.TransportError as exc:
+                if attempt == self._max_retries:
+                    raise
+                last_exc = exc
+
+        raise last_exc  # type: ignore[misc]
+
+    async def _get(self, path: str, params: dict[str, str] | None = None) -> Any:
+        res = await self._request("GET", path, params=params)
+        return _normalise(self._parse(res))
+
+    async def _post(self, path: str, body: Any = None) -> Any:
+        res = await self._request("POST", path, json=body)
+        return _normalise(self._parse(res))
+
+    async def _delete(self, path: str) -> None:
+        res = await self._request("DELETE", path)
+        if not res.is_success and res.status_code != 204:
+            self._raise(res)
+
+    def _parse(self, res: httpx.Response) -> Any:
+        if res.is_success:
+            return res.json()
+        self._raise(res)
+
+    def _raise(self, res: httpx.Response) -> None:
+        try:
+            body = res.json()
+        except Exception:
+            body = {}
+        error = body.get("error", {}) if isinstance(body, dict) else {}
+        code = error.get("code") if isinstance(error, dict) else None
+        message = (error.get("message") if isinstance(error, dict) else None) or f"HTTP {res.status_code}"
+
+        if res.status_code == 401:
+            raise AuthError(message, code)
+        if res.status_code == 402:
+            raise PlanError(message, body.get("requiredPlan") if isinstance(body, dict) else None)
+        if res.status_code == 404:
+            raise NotFoundError(message, code)
+        if res.status_code == 429:
+            retry_after = res.headers.get("Retry-After")
+            raise RateLimitError(message, int(retry_after) if retry_after else None)
+        raise Form4ApiError(message, res.status_code, code)

form4api/_errors.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+
+class Form4ApiError(Exception):
+    def __init__(self, message: str, status_code: int, error_code: str | None = None) -> None:
+        super().__init__(message)
+        self.status_code = status_code
+        self.error_code = error_code
+
+
+class AuthError(Form4ApiError):
+    def __init__(self, message: str, error_code: str | None = None) -> None:
+        super().__init__(message, 401, error_code)
+
+
+class PlanError(Form4ApiError):
+    def __init__(self, message: str, required_plan: str | None = None) -> None:
+        super().__init__(message, 402, "PLAN_REQUIRED")
+        self.required_plan = required_plan
+
+
+class NotFoundError(Form4ApiError):
+    def __init__(self, message: str, error_code: str | None = None) -> None:
+        super().__init__(message, 404, error_code)
+
+
+class RateLimitError(Form4ApiError):
+    def __init__(self, message: str, retry_after: int | None = None) -> None:
+        super().__init__(message, 429, "RATE_LIMIT_EXCEEDED")
+        self.retry_after = retry_after

form4api/_types.py

@@ -0,0 +1,88 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass
+class Transaction:
+    ticker: str
+    company_name: str
+    insider_name: str
+    insider_cik: str
+    accession_number: str
+    security_title: str
+    transaction_code: str
+    shares_amount: float
+    price_per_share: float | None
+    shares_owned_after: float | None
+    direct_indirect: str | None
+    is_derivative: bool
+    transaction_date: str
+    period_of_report: str
+
+
+@dataclass
+class Insider:
+    cik: str
+    name: str
+    is_director: bool
+    is_officer: bool
+    is_ten_percent_owner: bool
+    officer_title: str | None
+    total_filings: int
+
+
+@dataclass
+class Company:
+    cik: str
+    name: str
+    ticker: str | None
+    exchange: str | None
+    total_filings: int
+    active_insiders: int
+
+
+@dataclass
+class InsiderSignal:
+    ticker: str | None
+    company_name: str
+    signal_date: str
+    buy_sell_ratio: float
+    is_cluster_buy: bool
+    is_cluster_sell: bool
+    insider_count: int
+
+
+@dataclass
+class WebhookCreated:
+    subscription_id: int
+    url: str
+    event_types: list[str]
+    secret: str
+    created_at: str
+    warning: str | None
+
+
+@dataclass
+class WebhookSubscription:
+    subscription_id: int
+    url: str
+    event_types: list[str]
+    created_at: str
+    is_active: bool
+
+
+@dataclass
+class WebhookEvent:
+    delivery_id: int
+    subscription_id: int
+    event_type: str
+    attempt_count: int
+    delivered_at: str | None
+    next_retry_at: str | None
+    last_status_code: int | None
+    is_dead: bool
+    payload: str
+
+
+

form4api/_webhook_utils.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+import hashlib
+import hmac
+
+
+def verify_webhook(payload: str | bytes, signature: str, secret: str) -> bool:
+    """Return True if the X-Insider-Signature header matches the payload.
+
+    Usage::
+
+        body = request.get_data(as_text=True)
+        sig  = request.headers["X-Insider-Signature"]
+        if not verify_webhook(body, sig, WEBHOOK_SECRET):
+            abort(401)
+    """
+    if isinstance(payload, str):
+        payload = payload.encode()
+    expected = "sha256=" + hmac.new(secret.encode(), payload, hashlib.sha256).hexdigest()
+    return hmac.compare_digest(expected, signature)
+
+
+

form4api/resources/__init__.py

@@ -0,0 +1,16 @@
+from form4api.resources._companies import CompaniesResource
+from form4api.resources._insiders import InsidersResource
+from form4api.resources._signals import SignalsResource
+from form4api.resources._transactions import TransactionsResource
+from form4api.resources._webhooks import WebhooksResource
+
+__all__ = [
+    "CompaniesResource",
+    "InsidersResource",
+    "SignalsResource",
+    "TransactionsResource",
+    "WebhooksResource",
+]
+
+
+

form4api/resources/_companies.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from form4api._types import Company, Insider
+
+if TYPE_CHECKING:
+    from form4api._client import Form4ApiClient
+
+
+class CompaniesResource:
+    def __init__(self, client: Form4ApiClient) -> None:
+        self._client = client
+
+    def get(self, ticker: str) -> Company:
+        data = self._client._get(f"/v1/companies/{ticker}")
+        return Company(**data)
+
+    def insiders(self, ticker: str) -> list[Insider]:
+        data = self._client._get(f"/v1/companies/{ticker}/insiders")
+        return [Insider(**item) for item in data]
+
+
+

form4api/resources/_insiders.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from form4api._types import Insider, Transaction
+
+if TYPE_CHECKING:
+    from form4api._client import Form4ApiClient
+
+
+class InsidersResource:
+    def __init__(self, client: Form4ApiClient) -> None:
+        self._client = client
+
+    def get(self, cik: str) -> Insider:
+        data = self._client._get(f"/v1/insiders/{cik}")
+        return Insider(**data)
+
+    def transactions(
+        self,
+        cik: str,
+        *,
+        from_date: str | None = None,
+        to_date: str | None = None,
+        page: int = 1,
+        per_page: int = 50,
+    ) -> list[Transaction]:
+        params: dict[str, str] = {"page": str(page), "per_page": str(per_page)}
+        if from_date is not None:
+            params["from"] = from_date
+        if to_date is not None:
+            params["to"] = to_date
+        data = self._client._get(f"/v1/insiders/{cik}/transactions", params)
+        return [Transaction(**item) for item in data]
+
+
+

form4api/resources/_signals.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from form4api._types import InsiderSignal
+
+if TYPE_CHECKING:
+    from form4api._client import Form4ApiClient
+
+
+class SignalsResource:
+    def __init__(self, client: Form4ApiClient) -> None:
+        self._client = client
+
+    def list(
+        self,
+        *,
+        ticker: str | None = None,
+        page: int = 1,
+        per_page: int = 100,
+    ) -> list[InsiderSignal]:
+        params: dict[str, str] = {"page": str(page), "per_page": str(per_page)}
+        if ticker is not None:
+            params["ticker"] = ticker
+        data = self._client._get("/v1/signals", params)
+        return [InsiderSignal(**item) for item in data]
+
+
+

form4api/resources/_transactions.py

@@ -0,0 +1,70 @@
+from __future__ import annotations
+
+from collections.abc import Generator
+from typing import TYPE_CHECKING
+
+from form4api._types import Transaction
+
+if TYPE_CHECKING:
+    from form4api._client import Form4ApiClient
+
+
+class TransactionsResource:
+    def __init__(self, client: Form4ApiClient) -> None:
+        self._client = client
+
+    def list(
+        self,
+        *,
+        ticker: str | None = None,
+        cik: str | None = None,
+        insider_cik: str | None = None,
+        code: str | None = None,
+        from_date: str | None = None,
+        to_date: str | None = None,
+        page: int = 1,
+        per_page: int = 50,
+    ) -> list[Transaction]:
+        params: dict[str, str] = {"page": str(page), "per_page": str(per_page)}
+        if ticker is not None:
+            params["ticker"] = ticker
+        if cik is not None:
+            params["cik"] = cik
+        if insider_cik is not None:
+            params["insider_cik"] = insider_cik
+        if code is not None:
+            params["code"] = code
+        if from_date is not None:
+            params["from"] = from_date
+        if to_date is not None:
+            params["to"] = to_date
+        data = self._client._get("/v1/transactions", params)
+        return [Transaction(**item) for item in data]
+
+    def paginate(
+        self,
+        *,
+        ticker: str | None = None,
+        cik: str | None = None,
+        insider_cik: str | None = None,
+        code: str | None = None,
+        from_date: str | None = None,
+        to_date: str | None = None,
+        per_page: int = 50,
+    ) -> Generator[list[Transaction], None, None]:
+        page = 1
+        while True:
+            batch = self.list(
+                ticker=ticker, cik=cik, insider_cik=insider_cik,
+                code=code, from_date=from_date, to_date=to_date,
+                page=page, per_page=per_page,
+            )
+            if not batch:
+                break
+            yield batch
+            if len(batch) < per_page:
+                break
+            page += 1
+
+
+

form4api/resources/_webhooks.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from form4api._types import WebhookCreated, WebhookEvent, WebhookSubscription
+
+if TYPE_CHECKING:
+    from form4api._client import Form4ApiClient
+
+
+class WebhooksResource:
+    def __init__(self, client: Form4ApiClient) -> None:
+        self._client = client
+
+    def create(self, url: str, event_types: list[str]) -> WebhookCreated:
+        data = self._client._post("/v1/webhooks", {"url": url, "eventTypes": event_types})
+        return WebhookCreated(**data)
+
+    def list(self) -> list[WebhookSubscription]:
+        data = self._client._get("/v1/webhooks")
+        return [WebhookSubscription(**item) for item in data]
+
+    def delete(self, subscription_id: int) -> None:
+        self._client._delete(f"/v1/webhooks/{subscription_id}")
+
+    def events(self, *, since: str | None = None) -> list[WebhookEvent]:
+        params: dict[str, str] = {}
+        if since is not None:
+            params["since"] = since
+        data = self._client._get("/v1/webhooks/events", params or None)
+        return [WebhookEvent(**item) for item in data]
+
+
+

form4api-0.1.0.dist-info/METADATA

@@ -0,0 +1,104 @@
+Metadata-Version: 2.4
+Name: form4api
+Version: 0.1.0
+Summary: Python client for the Form4API — real-time SEC Form 4 insider trading data
+License-Expression: MIT
+Project-URL: Homepage, https://form4api.com
+Project-URL: Documentation, https://form4api.com/docs
+Project-URL: Repository, https://github.com/theodor90/form4api-py.git
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: httpx>=0.27
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Requires-Dist: pytest-httpx>=0.30; extra == "dev"
+Requires-Dist: respx>=0.21; extra == "dev"
+Dynamic: license-file
+
+# form4api
+
+Python client for [Form4API](https://form4api.com) — real-time SEC Form 4 insider trading data.
+
+Supports Python 3.11+. Uses `httpx` for both sync and async HTTP.
+
+## Installation
+
+```bash
+pip install form4api
+```
+
+## Sync quickstart
+
+```python
+from form4api import Form4ApiClient
+
+client = Form4ApiClient("YOUR_API_KEY")
+
+# Recent open-market purchases at Apple
+txns = client.transactions.list(ticker="AAPL", code="P", per_page=5)
+for t in txns:
+    print(t.insider_name, t.shares_amount, "@", t.price_per_share)
+
+# Company overview
+company = client.companies.get("MSFT")
+print(company.name, company.active_insiders, "active insiders")
+
+# Insider detail
+insider = client.insiders.get("0001234567")
+print(insider.name, insider.officer_title)
+
+# Cluster-buy signals (Business plan)
+signals = client.signals.list(ticker="NVDA")
+for sig in signals:
+    if sig.is_cluster_buy:
+        print(sig.company_name, sig.insider_count, "buyers")
+```
+
+## Async quickstart
+
+```python
+import asyncio
+from form4api import AsyncForm4ApiClient
+
+async def main():
+    async with AsyncForm4ApiClient("YOUR_API_KEY") as client:
+        txns = await client.transactions.list(ticker="AAPL", per_page=5)
+        for t in txns:
+            print(t.insider_name, t.shares_amount, "@", t.price_per_share)
+
+asyncio.run(main())
+```
+
+## Resources
+
+| Resource | Methods |
+|---|---|
+| `client.transactions` | `.list(**params)`, `.paginate(**params)` |
+| `client.insiders` | `.get(cik)`, `.transactions(cik, **params)` |
+| `client.companies` | `.get(ticker)`, `.insiders(ticker)` |
+| `client.signals` | `.list(**params)` — Business plan |
+| `client.webhooks` | `.create(url, event_types)`, `.list()`, `.delete(id)`, `.events(**params)` |
+
+## Error handling
+
+```python
+from form4api import Form4ApiClient, AuthError, PlanError, RateLimitError, NotFoundError
+
+client = Form4ApiClient("YOUR_API_KEY")
+
+try:
+    signals = client.signals.list()
+except PlanError as e:
+    print(f"Upgrade to {e.required_plan}")
+except RateLimitError as e:
+    print(f"Retry after {e.retry_after}s")
+except AuthError:
+    print("Invalid API key")
+except NotFoundError:
+    print("Resource not found")
+```
+
+## License
+
+MIT

form4api-0.1.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+form4api/__init__.py,sha256=HrjpVKXtA4Yn5qdQhkbY6FF7OswTfZNkN6mDCB4Iyus,692
+form4api/_client.py,sha256=uDEXT3IXQaMExe2S9nzEZvCrXbiGaLtwAf9bOJzZ7P0,7778
+form4api/_errors.py,sha256=4uFjdBBtqcPbPX-aC_GZSv7Mk-ggF0O22cYzvfAXy7U,1033
+form4api/_types.py,sha256=NIB9X8FC52OWpdLCxwfH218uzdZw5IJJyk3jtT9DoVM,1556
+form4api/_webhook_utils.py,sha256=qrCyrG-xGyri2qx7VyTvV6Z8x3PpN4UMzKQS9OBvInw,637
+form4api/resources/__init__.py,sha256=wnxFFSoATYQuHtZMhXIr_qsq5UoJHmacxrfDGkVX4rg,443
+form4api/resources/_companies.py,sha256=e42g0_wDYeVX1Zj-ldOY9FJ2J_xXGdmVPDfeCh9CXpY,610
+form4api/resources/_insiders.py,sha256=hUJmk0dQSb1XR5ZVwBsu0rKCSt7XpOa_u6S0r29Hxv8,1002
+form4api/resources/_signals.py,sha256=xFD8EoWo2_HfMzKuauejDHxfXiPC9ZES1NfpmED9_Xk,714
+form4api/resources/_transactions.py,sha256=ZM9V4SMcrbnMn5TB5_Tdxm9PVumv6bEPNdWFgI3tDf4,2030
+form4api/resources/_webhooks.py,sha256=woxntFJ-ijHF1s2gNCq4pYEhlb0v4vMb1hFmngVW3VQ,1118
+form4api-0.1.0.dist-info/licenses/LICENSE,sha256=hBjmLmmuTZHQ1mTKUfOK2QmRI-yBOB8S4qSFMNiks34,1065
+form4api-0.1.0.dist-info/METADATA,sha256=3OkKmj4xd6eeZJt8Qo2DFh5ekLpHSAByU4eulTO4QJA,2802
+form4api-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+form4api-0.1.0.dist-info/top_level.txt,sha256=TyId6H-cZi4IafOPtFJN55RjwW63LFqnwPQ88jRh-qc,9
+form4api-0.1.0.dist-info/RECORD,,

form4api-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
+

form4api-0.1.0.dist-info/licenses/LICENSE

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

form4api-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+form4api