opaige 1.0.0__tar.gz

opaige-1.0.0/LICENSE

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

opaige-1.0.0/PKG-INFO

@@ -0,0 +1,45 @@
+Metadata-Version: 2.4
+Name: opaige
+Version: 1.0.0
+Summary: The Opaige API for Python: visa requirements, file review, forms, bookings, lodgements and webhooks.
+License-Expression: MIT
+Project-URL: Homepage, https://opaige.com/developers
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# Opaige for Python
+
+The Opaige API from Python 3.8 or later. Standard library only.
+
+```python
+import os
+from opaige import Opaige, OpaigeError, verify_webhook
+
+opaige = Opaige(os.environ["OPAIGE_KEY"])
+
+answer = opaige.check_requirements(passport="IN", destination="FR")
+
+opaige.send_bookings(body={"bookings": [{
+    "ref": "QX7K2M", "flight": {"number": "OP412", "destination": "GB", "depart_date": "2026-12-18"},
+    "passengers": [{"ref": "QX7K2M-1", "passport": "IN", "residence": "AE"}],
+}]})
+
+review = opaige.review_file(file=pdf_bytes, fields={"destination": "FR", "purpose": "business"}, idempotency_key="file-8841")
+```
+
+Every method is one API call, named as in the [API reference](https://opaige.com/developers), in snake_case. JSON goes in `body`;
+a PDF comes back as `bytes`. A query value that is a Python word gets an underscore: `list_invoices(from_="2026-10-01")`.
+
+**Errors** raise `OpaigeError` with `status`, `code`, `request_id` (quote it to support) and `details`.
+**Retries:** reads, and writes sent with an `idempotency_key`, are tried again after 429 and 5xx answers (`max_retries`, default 2).
+**Sandbox:** a sandbox key answers in the same shape and saves and bills nothing.
+
+## Webhooks
+
+```python
+event = verify_webhook(request.get_data(), request.headers.get("Opaige-Signature"), os.environ["OPAIGE_WEBHOOK_SECRET"])
+```
+
+Pass the raw body: a parsed and re-serialised body no longer matches its signature.

opaige-1.0.0/README.md

@@ -0,0 +1,34 @@
+# Opaige for Python
+
+The Opaige API from Python 3.8 or later. Standard library only.
+
+```python
+import os
+from opaige import Opaige, OpaigeError, verify_webhook
+
+opaige = Opaige(os.environ["OPAIGE_KEY"])
+
+answer = opaige.check_requirements(passport="IN", destination="FR")
+
+opaige.send_bookings(body={"bookings": [{
+    "ref": "QX7K2M", "flight": {"number": "OP412", "destination": "GB", "depart_date": "2026-12-18"},
+    "passengers": [{"ref": "QX7K2M-1", "passport": "IN", "residence": "AE"}],
+}]})
+
+review = opaige.review_file(file=pdf_bytes, fields={"destination": "FR", "purpose": "business"}, idempotency_key="file-8841")
+```
+
+Every method is one API call, named as in the [API reference](https://opaige.com/developers), in snake_case. JSON goes in `body`;
+a PDF comes back as `bytes`. A query value that is a Python word gets an underscore: `list_invoices(from_="2026-10-01")`.
+
+**Errors** raise `OpaigeError` with `status`, `code`, `request_id` (quote it to support) and `details`.
+**Retries:** reads, and writes sent with an `idempotency_key`, are tried again after 429 and 5xx answers (`max_retries`, default 2).
+**Sandbox:** a sandbox key answers in the same shape and saves and bills nothing.
+
+## Webhooks
+
+```python
+event = verify_webhook(request.get_data(), request.headers.get("Opaige-Signature"), os.environ["OPAIGE_WEBHOOK_SECRET"])
+```
+
+Pass the raw body: a parsed and re-serialised body no longer matches its signature.

opaige-1.0.0/opaige/__init__.py

@@ -0,0 +1,20 @@
+"""The Opaige API for Python (2026-11-03). Every method is one API call, named as in the API reference (opaige.com/developers):
+
+    from opaige import Opaige
+    opaige = Opaige(os.environ["OPAIGE_KEY"])
+    answer = opaige.check_requirements(passport="IN", destination="FR")
+    opaige.send_bookings(body={"bookings": [...]})
+
+A sandbox key answers in the same shape and saves and bills nothing. Standard library only.
+"""
+from .operations import Operations
+from .request import VERSION, OpaigeError, Requester
+from .webhooks import verify_webhook
+
+
+class Opaige(Operations):
+    def __init__(self, key: str, base_url: str = "https://opaige.com/api/company/v1", timeout: float = 120.0, max_retries: int = 2) -> None:
+        super().__init__(Requester(key, base_url=base_url, timeout=timeout, max_retries=max_retries))
+
+
+__all__ = ["Opaige", "OpaigeError", "verify_webhook", "VERSION"]

opaige-1.0.0/opaige/operations.py

@@ -0,0 +1,171 @@
+# Generated by scripts/sdk/generate.mjs from the OpenAPI description (2026-11-01). Do not edit by hand.
+
+from typing import Any, Dict, Optional, Union
+
+from .request import Requester
+
+
+class Operations:
+    def __init__(self, http: Requester) -> None:
+        self._http = http
+
+    def list_appointments(self, *, date: Optional[Union[str, int]] = None) -> Any:
+        """A day’s appointments with the file state and the counter stage. GET /appointments"""
+        return self._http.request("GET", f"/appointments", query={"date": date})
+
+    def send_appointments(self, *, body: Dict[str, Any]) -> Any:
+        """Appointments, from a visa centre’s booking system. POST /appointments"""
+        return self._http.request("POST", f"/appointments", query=None, body=body)
+
+    def list_bookings(self, *, updated_since: Optional[Union[str, int]] = None) -> Any:
+        """Your bookings with every nudge sent or due. GET /bookings"""
+        return self._http.request("GET", f"/bookings", query={"updated_since": updated_since})
+
+    def send_bookings(self, *, body: Dict[str, Any]) -> Any:
+        """Bookings, from an airline’s or travel platform’s reservation system: who needs a visa or travel permission, and when each passenger is nudged. POST /bookings"""
+        return self._http.request("POST", f"/bookings", query=None, body=body)
+
+    def get_booking(self, *, ref: str) -> Any:
+        """One booking by your reference. GET /bookings/{ref}"""
+        return self._http.request("GET", f"/bookings/{_q(ref)}", query=None)
+
+    def get_case_file(self, *, id: str) -> Any:
+        """A case’s finished file, with fresh links. GET /cases/{id}/file"""
+        return self._http.request("GET", f"/cases/{_q(id)}/file", query=None)
+
+    def resend_case_file(self, *, id: str) -> Any:
+        """Send file.ready again. POST /cases/{id}/file"""
+        return self._http.request("POST", f"/cases/{_q(id)}/file", query=None)
+
+    def make_document(self, *, body: Dict[str, Any], format: Optional[Union[str, int]] = None) -> Any:
+        """An itinerary, cover letter, submission brief or third-party letter. POST /documents"""
+        return self._http.request("POST", f"/documents", query={"format": format}, body=body)
+
+    def review_file(self, *, body: Optional[Dict[str, Any]] = None, file: Optional[bytes] = None, filename: str = "file.pdf", fields: Optional[Dict[str, str]] = None, idempotency_key: Optional[str] = None) -> Any:
+        """Every inconsistency in a whole visa file. POST /file-review"""
+        return self._http.request("POST", f"/file-review", query=None, body=body, file=file, filename=filename, fields=fields, idempotency_key=idempotency_key)
+
+    def get_file_review(self, *, id: str) -> Any:
+        """A review made earlier. GET /file-review/{id}"""
+        return self._http.request("GET", f"/file-review/{_q(id)}", query=None)
+
+    def create_upload(self) -> Any:
+        """A place to PUT a large PDF before reviewing it. POST /file-review/uploads"""
+        return self._http.request("POST", f"/file-review/uploads", query=None)
+
+    def list_ready_files(self, *, since: Optional[Union[str, int]] = None) -> Any:
+        """Every file that became ready since a moment: the daily batch. GET /files"""
+        return self._http.request("GET", f"/files", query={"since": since})
+
+    def fill_form(self, *, body: Dict[str, Any], format: Optional[Union[str, int]] = None) -> Any:
+        """The official visa form, filled from answers. POST /forms"""
+        return self._http.request("POST", f"/forms", query={"format": format}, body=body)
+
+    def list_invoices(self, *, status: Optional[Union[str, int]] = None, from_: Optional[Union[str, int]] = None, to: Optional[Union[str, int]] = None) -> Any:
+        """Every case billed, due or paid. GET /invoices"""
+        return self._http.request("GET", f"/invoices", query={"status": status, "from": from_, "to": to})
+
+    def list_lodgements(self) -> Any:
+        """Your lodgements, newest first. GET /lodgements"""
+        return self._http.request("GET", f"/lodgements", query=None)
+
+    def create_lodgement(self, *, body: Dict[str, Any], idempotency_key: Optional[str] = None) -> Any:
+        """Fill a visa application on the government portal, parked before the declarations (au-600) or the photo and signature (us-ds160). POST /lodgements"""
+        return self._http.request("POST", f"/lodgements", query=None, body=body, idempotency_key=idempotency_key)
+
+    def get_lodgement(self, *, id: str) -> Any:
+        """Where a lodgement stands, with the government reference once there is one. GET /lodgements/{id}"""
+        return self._http.request("GET", f"/lodgements/{_q(id)}", query=None)
+
+    def attach_lodgement_documents(self, *, id: str, body: Dict[str, Any]) -> Any:
+        """Attach supporting documents. POST /lodgements/{id}/documents"""
+        return self._http.request("POST", f"/lodgements/{_q(id)}/documents", query=None, body=body)
+
+    def submit_lodgement(self, *, id: str, body: Dict[str, Any], idempotency_key: Optional[str] = None) -> Any:
+        """Lodge and pay the government fee (requires authorize: true). POST /lodgements/{id}/submit"""
+        return self._http.request("POST", f"/lodgements/{_q(id)}/submit", query=None, body=body, idempotency_key=idempotency_key)
+
+    def lodgement_questions(self, *, visa: Optional[Union[str, int]] = None, purpose: Optional[Union[str, int]] = None) -> Any:
+        """The questions a DS-160 lodgement answers, as a case asks them. GET /lodgements/questions"""
+        return self._http.request("GET", f"/lodgements/questions", query={"visa": visa, "purpose": purpose})
+
+    def check_passengers(self, *, body: Dict[str, Any]) -> Any:
+        """Who on a flight needs a visa, and by when to file. POST /passengers/check"""
+        return self._http.request("POST", f"/passengers/check", query=None, body=body)
+
+    def give_passenger_file(self, *, body: Dict[str, Any], idempotency_key: Optional[str] = None) -> Any:
+        """Give a passenger their visa file (billed per file). POST /passengers/file"""
+        return self._http.request("POST", f"/passengers/file", query=None, body=body, idempotency_key=idempotency_key)
+
+    def get_passenger_settings(self) -> Any:
+        """Your page for buying the file, and where passengers get help. GET /passengers/settings"""
+        return self._http.request("GET", f"/passengers/settings", query=None)
+
+    def update_passenger_settings(self, *, body: Dict[str, Any]) -> Any:
+        """Change them (null clears). PATCH /passengers/settings"""
+        return self._http.request("PATCH", f"/passengers/settings", query=None, body=body)
+
+    def passenger_status(self, *, ref: Optional[Union[str, int]] = None) -> Any:
+        """Stages of passengers who chose to share. GET /passengers/status"""
+        return self._http.request("GET", f"/passengers/status", query={"ref": ref})
+
+    def check_requirements(self, *, passport: Optional[Union[str, int]] = None, destination: Optional[Union[str, int]] = None, residence: Optional[Union[str, int]] = None, stay_days: Optional[Union[str, int]] = None) -> Any:
+        """What a passport needs for a destination. GET /requirements"""
+        return self._http.request("GET", f"/requirements", query={"passport": passport, "destination": destination, "residence": residence, "stay_days": stay_days})
+
+    def where_to_apply(self, *, residence: Optional[Union[str, int]] = None, destination: Optional[Union[str, int]] = None) -> Any:
+        """Who takes the application, where, and who decides it. GET /routes"""
+        return self._http.request("GET", f"/routes", query={"residence": residence, "destination": destination})
+
+    def list_rules(self) -> Any:
+        """Every destination the rules cover, with versions. GET /rules"""
+        return self._http.request("GET", f"/rules", query=None)
+
+    def get_rules(self, *, destination: str) -> Any:
+        """One destination: every passport grouped by what it needs, with sources. GET /rules/{destination}"""
+        return self._http.request("GET", f"/rules/{_q(destination)}", query=None)
+
+    def list_rule_notices(self, *, since: Optional[Union[str, int]] = None) -> Any:
+        """Rule changes announced, in force or coming up. GET /rules/notices"""
+        return self._http.request("GET", f"/rules/notices", query={"since": since})
+
+    def list_students(self) -> Any:
+        """Admitted students, with the visa stage where each agreed to share it. GET /students"""
+        return self._http.request("GET", f"/students", query=None)
+
+    def send_students(self, *, body: Dict[str, Any]) -> Any:
+        """Admitted students, from a school’s admissions system; each gets a visa link. POST /students"""
+        return self._http.request("POST", f"/students", query=None, body=body)
+
+    def sponsor_compliance(self, *, as_of: Optional[Union[str, int]] = None) -> Any:
+        """A UK sponsor’s refusal, enrolment and completion rates as the Basic Compliance Assessment works them. GET /students/compliance"""
+        return self._http.request("GET", f"/students/compliance", query={"as_of": as_of})
+
+    def student_funds_check(self, *, body: Dict[str, Any]) -> Any:
+        """Pre-CAS: a UK Student’s money against the Immigration Rules, each finding with its paragraph. POST /students/funds-check"""
+        return self._http.request("POST", f"/students/funds-check", query=None, body=body)
+
+    def list_trips(self, *, status: Optional[Union[str, int]] = None, updated_since: Optional[Union[str, int]] = None) -> Any:
+        """Trips and where each case stands. GET /trips"""
+        return self._http.request("GET", f"/trips", query={"status": status, "updated_since": updated_since})
+
+    def create_trip(self, *, body: Dict[str, Any]) -> Any:
+        """Plan a trip; it follows your approval rules. POST /trips"""
+        return self._http.request("POST", f"/trips", query=None, body=body)
+
+    def get_trip(self, *, id: str) -> Any:
+        """One trip, with its case. GET /trips/{id}"""
+        return self._http.request("GET", f"/trips/{_q(id)}", query=None)
+
+    def get_uptime(self, *, month: Optional[Union[str, int]] = None) -> Any:
+        """A month’s measured uptime against the 99.9% commitment. GET /uptime"""
+        return self._http.request("GET", f"/uptime", query={"month": month})
+
+    def get_usage(self, *, month: Optional[Union[str, int]] = None) -> Any:
+        """This month’s paid API use and what it comes to. GET /usage"""
+        return self._http.request("GET", f"/usage", query={"month": month})
+
+
+def _q(v: str) -> str:
+    from urllib.parse import quote
+    return quote(str(v), safe="")

opaige-1.0.0/opaige/request.py

@@ -0,0 +1,71 @@
+"""How every call is made: the key, the JSON or the file, retries and errors. Written by hand; the API methods beside it
+(operations.py) are generated from the API description. Standard library only."""
+import json
+import time
+import uuid
+import urllib.error
+import urllib.parse
+import urllib.request
+from typing import Any, Dict, Optional
+
+VERSION = "1.0.0"
+_RETRY = {429, 500, 502, 503, 504}
+
+
+class OpaigeError(Exception):
+    def __init__(self, message: str, status: int, code: Optional[str] = None, request_id: Optional[str] = None, details: Any = None):
+        super().__init__(message)
+        self.status, self.code, self.request_id, self.details = status, code, request_id, details
+
+
+class Requester:
+    def __init__(self, key: str, base_url: str = "https://opaige.com/api/company/v1", timeout: float = 120.0, max_retries: int = 2):
+        if not key:
+            raise ValueError("An Opaige API key is required: create one in the portal under Developers.")
+        self._key, self._base, self._timeout, self._retries = key, base_url.rstrip("/"), timeout, max_retries
+
+    def request(self, method: str, path: str, query: Optional[Dict[str, Any]] = None, body: Any = None,
+                file: Optional[bytes] = None, filename: str = "file.pdf", fields: Optional[Dict[str, str]] = None,
+                idempotency_key: Optional[str] = None) -> Any:
+        q = {k: v for k, v in (query or {}).items() if v is not None and v != ""}
+        url = self._base + path + ("?" + urllib.parse.urlencode(q) if q else "")
+        headers = {"Authorization": f"Bearer {self._key}", "User-Agent": f"opaige-python/{VERSION}", "Accept": "application/json"}
+        if idempotency_key:
+            headers["Idempotency-Key"] = idempotency_key
+        data = None
+        if file is not None:
+            boundary = "opaige" + uuid.uuid4().hex
+            parts = [f'--{boundary}\r\nContent-Disposition: form-data; name="{k}"\r\n\r\n{v}\r\n'.encode() for k, v in (fields or {}).items()]
+            parts.append(f'--{boundary}\r\nContent-Disposition: form-data; name="file"; filename="{filename}"\r\nContent-Type: application/pdf\r\n\r\n'.encode() + file + b"\r\n")
+            data = b"".join(parts) + f"--{boundary}--\r\n".encode()
+            headers["Content-Type"] = f"multipart/form-data; boundary={boundary}"
+        elif body is not None:
+            data = json.dumps(body).encode()
+            headers["Content-Type"] = "application/json"
+        retryable = method == "GET" or bool(idempotency_key)
+        attempt = 0
+        while True:
+            req = urllib.request.Request(url, data=data, headers=headers, method=method)
+            try:
+                with urllib.request.urlopen(req, timeout=self._timeout) as res:
+                    raw = res.read()
+                    if "application/pdf" in (res.headers.get("Content-Type") or ""):
+                        return raw
+                    return json.loads(raw or b"{}")
+            except urllib.error.HTTPError as e:
+                if e.code in _RETRY and retryable and attempt < self._retries:
+                    wait = e.headers.get("Retry-After")
+                    time.sleep(min(float(wait), 30.0) if wait and wait.replace(".", "", 1).isdigit() else 0.5 * 2 ** attempt)
+                    attempt += 1
+                    continue
+                try:
+                    out = json.loads(e.read() or b"{}")
+                except ValueError:
+                    out = {}
+                raise OpaigeError(out.get("error") or f"Opaige answered {e.code}", e.code, out.get("code"), e.headers.get("Opaige-Request-Id"), out.get("details")) from None
+            except urllib.error.URLError as e:
+                if retryable and attempt < self._retries:
+                    time.sleep(0.5 * 2 ** attempt)
+                    attempt += 1
+                    continue
+                raise OpaigeError(f"Could not reach Opaige: {e.reason}", 0, "network_error") from None

opaige-1.0.0/opaige/webhooks.py

@@ -0,0 +1,28 @@
+"""Checks that a webhook came from Opaige and was not replayed.
+
+Pass the raw request body exactly as received, the Opaige-Signature header and your endpoint's signing secret:
+    Opaige-Signature: t=<unix seconds>,v1=<hex HMAC-SHA256 of "<t>.<raw body>">
+"""
+import hashlib
+import hmac
+import json
+import time
+from typing import Any, Dict, Optional, Union
+
+
+def verify_webhook(raw_body: Union[str, bytes], signature: Optional[str], secret: str, tolerance_seconds: int = 300, now: Optional[float] = None) -> Dict[str, Any]:
+    body = raw_body.decode() if isinstance(raw_body, bytes) else raw_body
+    parts = dict(p.strip().split("=", 1) for p in (signature or "").split(",") if "=" in p)
+    try:
+        t = int(parts.get("t", ""))
+    except ValueError:
+        raise ValueError("Opaige-Signature is missing or malformed.") from None
+    v1 = parts.get("v1")
+    if not v1:
+        raise ValueError("Opaige-Signature is missing or malformed.")
+    if abs((now if now is not None else time.time()) - t) > tolerance_seconds:
+        raise ValueError("Opaige-Signature is too old: a replay, or a clock far off.")
+    want = hmac.new(secret.encode(), f"{t}.{body}".encode(), hashlib.sha256).hexdigest()
+    if not hmac.compare_digest(want, v1):
+        raise ValueError("Opaige-Signature does not match this body and secret.")
+    return json.loads(body)

opaige-1.0.0/opaige.egg-info/PKG-INFO

@@ -0,0 +1,45 @@
+Metadata-Version: 2.4
+Name: opaige
+Version: 1.0.0
+Summary: The Opaige API for Python: visa requirements, file review, forms, bookings, lodgements and webhooks.
+License-Expression: MIT
+Project-URL: Homepage, https://opaige.com/developers
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# Opaige for Python
+
+The Opaige API from Python 3.8 or later. Standard library only.
+
+```python
+import os
+from opaige import Opaige, OpaigeError, verify_webhook
+
+opaige = Opaige(os.environ["OPAIGE_KEY"])
+
+answer = opaige.check_requirements(passport="IN", destination="FR")
+
+opaige.send_bookings(body={"bookings": [{
+    "ref": "QX7K2M", "flight": {"number": "OP412", "destination": "GB", "depart_date": "2026-12-18"},
+    "passengers": [{"ref": "QX7K2M-1", "passport": "IN", "residence": "AE"}],
+}]})
+
+review = opaige.review_file(file=pdf_bytes, fields={"destination": "FR", "purpose": "business"}, idempotency_key="file-8841")
+```
+
+Every method is one API call, named as in the [API reference](https://opaige.com/developers), in snake_case. JSON goes in `body`;
+a PDF comes back as `bytes`. A query value that is a Python word gets an underscore: `list_invoices(from_="2026-10-01")`.
+
+**Errors** raise `OpaigeError` with `status`, `code`, `request_id` (quote it to support) and `details`.
+**Retries:** reads, and writes sent with an `idempotency_key`, are tried again after 429 and 5xx answers (`max_retries`, default 2).
+**Sandbox:** a sandbox key answers in the same shape and saves and bills nothing.
+
+## Webhooks
+
+```python
+event = verify_webhook(request.get_data(), request.headers.get("Opaige-Signature"), os.environ["OPAIGE_WEBHOOK_SECRET"])
+```
+
+Pass the raw body: a parsed and re-serialised body no longer matches its signature.

opaige-1.0.0/opaige.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+LICENSE
+README.md
+pyproject.toml
+opaige/__init__.py
+opaige/operations.py
+opaige/request.py
+opaige/webhooks.py
+opaige.egg-info/PKG-INFO
+opaige.egg-info/SOURCES.txt
+opaige.egg-info/dependency_links.txt
+opaige.egg-info/top_level.txt

opaige-1.0.0/opaige.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

opaige-1.0.0/opaige.egg-info/top_level.txt

@@ -0,0 +1 @@
+opaige

opaige-1.0.0/pyproject.toml

@@ -0,0 +1,19 @@
+[project]
+name = "opaige"
+version = "1.0.0"
+description = "The Opaige API for Python: visa requirements, file review, forms, bookings, lodgements and webhooks."
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.8"
+dependencies = []
+
+[project.urls]
+Homepage = "https://opaige.com/developers"
+
+[build-system]
+requires = ["setuptools>=77"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools]
+packages = ["opaige"]

opaige-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+