cdo-oracle-sdk 0.1.0__tar.gz

cdo_oracle_sdk-0.1.0/PKG-INFO

@@ -0,0 +1,25 @@
+Metadata-Version: 2.4
+Name: cdo-oracle-sdk
+Version: 0.1.0
+Summary: Python SDK for the RunOnProof decision API
+Author-email: RunOnProof <institucional@aureumone.io>
+License-Expression: MIT
+Project-URL: Homepage, https://runonproof.com
+Project-URL: Documentation, https://docs.runonproof.com/docs
+Project-URL: Repository, https://github.com/runonproof/cdo
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Provides-Extra: crypto
+Requires-Dist: cryptography>=45; extra == "crypto"
+
+# RunOnProof Python SDK
+
+`cdo-oracle-sdk` is the supported Python client for the RunOnProof decision API.
+It exposes synchronous and asynchronous clients for the Brazil and United Kingdom
+decision products, including company checks, supplier approval, invoice and payee
+verification, payment authorization, vendor changes, and Company Passport operations.
+
+The client is fail-closed: it preserves evidence, correlation and idempotency fields,
+uses bounded network operations, and does not sign transactions or settle payments.
+See the [RunOnProof documentation](https://docs.runonproof.com/docs) for API setup and
+credential handling.

cdo_oracle_sdk-0.1.0/README.md

@@ -0,0 +1,11 @@
+# RunOnProof Python SDK
+
+`cdo-oracle-sdk` is the supported Python client for the RunOnProof decision API.
+It exposes synchronous and asynchronous clients for the Brazil and United Kingdom
+decision products, including company checks, supplier approval, invoice and payee
+verification, payment authorization, vendor changes, and Company Passport operations.
+
+The client is fail-closed: it preserves evidence, correlation and idempotency fields,
+uses bounded network operations, and does not sign transactions or settle payments.
+See the [RunOnProof documentation](https://docs.runonproof.com/docs) for API setup and
+credential handling.

cdo_oracle_sdk-0.1.0/pyproject.toml

@@ -0,0 +1,24 @@
+[build-system]
+requires = ["setuptools>=77"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "cdo-oracle-sdk"
+version = "0.1.0"
+requires-python = ">=3.11"
+description = "Python SDK for the RunOnProof decision API"
+readme = "README.md"
+license = "MIT"
+authors = [{ name = "RunOnProof", email = "institucional@aureumone.io" }]
+dependencies = []
+
+[project.urls]
+Homepage = "https://runonproof.com"
+Documentation = "https://docs.runonproof.com/docs"
+Repository = "https://github.com/runonproof/cdo"
+
+[project.optional-dependencies]
+crypto = ["cryptography>=45"]
+
+[tool.setuptools.packages.find]
+where = ["src"]

cdo_oracle_sdk-0.1.0/setup.cfg

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

cdo_oracle_sdk-0.1.0/src/cdo_oracle/__init__.py

@@ -0,0 +1,3 @@
+from .client import OracleClient, OracleError, verify_ed25519_token
+
+__all__ = ["OracleClient", "OracleError", "verify_ed25519_token"]

cdo_oracle_sdk-0.1.0/src/cdo_oracle/client.py

@@ -0,0 +1,141 @@
+from __future__ import annotations
+import asyncio, base64, json, time
+from dataclasses import dataclass
+from typing import Any, Mapping
+from urllib.error import HTTPError
+from urllib.parse import quote
+from urllib.request import Request, urlopen
+
+class OracleError(RuntimeError):
+    def __init__(self, code: str, status: int = 0, details: Any = None): super().__init__(code); self.code=code; self.status=status; self.details=details
+
+@dataclass(frozen=True)
+class ClientOptions:
+    base_url: str
+    bearer_token: str | None = None
+    timeout: float = 8.0
+    retries: int = 2
+
+class Transport:
+    def __init__(self, options: ClientOptions): self.options=options
+    def request(self, method: str, path: str, body: Mapping[str,Any] | None=None, *, idempotency_key: str | None=None, payment_signature: str | None=None, request_body_digest: str | None=None, timeout: float | None=None) -> dict[str,Any]:
+        payload=dict(body or {}); headers={"Accept":"application/json"}
+        if idempotency_key: payload["idempotency_key"]=idempotency_key; headers["Idempotency-Key"]=idempotency_key
+        if payment_signature: headers["Payment-Signature"]=payment_signature
+        if request_body_digest: headers["X-CDO-Request-Body-Digest"]=request_body_digest
+        if self.options.bearer_token: headers["Authorization"]=f"Bearer {self.options.bearer_token}"
+        data=None if body is None else json.dumps(payload,separators=(",", ":")).encode();
+        if data is not None: headers["Content-Type"]="application/json"
+        for attempt in range(self.options.retries+1):
+            try:
+                with urlopen(Request(self.options.base_url.rstrip("/")+path,data=data,headers=headers,method=method),timeout=timeout or self.options.timeout) as response: return json.loads(response.read())
+            except HTTPError as error:
+                details=_json(error.read()); retryable=error.code in (429,500,502,503,504) and (method=="GET" or idempotency_key is not None)
+                if retryable and attempt<self.options.retries: time.sleep(.15*(2**attempt)); continue
+                raise OracleError(str(details.get("code",f"HTTP_{error.code}")),error.code,details) from error
+    async def arequest(self,*args:Any,**kwargs:Any)->dict[str,Any]: return await asyncio.to_thread(self.request,*args,**kwargs)
+
+class UkClient:
+    def __init__(self, transport:Transport): self._t=transport
+    def _post(self,path:str,payload:Mapping[str,Any],idempotency_key:str|None=None,payment_signature:str|None=None,request_body_digest:str|None=None)->dict[str,Any]: return _validate_envelope(self._t.request("POST",path,payload,idempotency_key=idempotency_key,payment_signature=payment_signature,request_body_digest=request_body_digest))
+    def resolve_legal_entity(self,payload:Mapping[str,Any],**kw:Any)->dict[str,Any]: return self._post("/v1/gb/entities/resolve",payload,kw.get("idempotency_key"),kw.get("payment_signature"),kw.get("request_body_digest"))
+    def verify_company_status(self,payload:Mapping[str,Any],**kw:Any)->dict[str,Any]: return self._post("/v1/gb/companies/legal-status",payload,kw.get("idempotency_key"),kw.get("payment_signature"),kw.get("request_body_digest"))
+    def match_invoice_to_company(self,payload:Mapping[str,Any],**kw:Any)->dict[str,Any]: return self._post("/v1/gb/invoices/match-company",payload,kw.get("idempotency_key"),kw.get("payment_signature"),kw.get("request_body_digest"))
+    def match_business_payee(self,payload:Mapping[str,Any],**kw:Any)->dict[str,Any]: return self._post("/v1/gb/payees/match-business",payload,kw.get("idempotency_key"),kw.get("payment_signature"),kw.get("request_body_digest"))
+    def authorize_vendor_payment_detail_change(self,payload:Mapping[str,Any],**kw:Any)->dict[str,Any]: return self._post("/v1/gb/vendors/authorize-payment-detail-change",payload,kw.get("idempotency_key"),kw.get("payment_signature"),kw.get("request_body_digest"))
+    def screen_restricted_party(self,payload:Mapping[str,Any],**kw:Any)->dict[str,Any]: return self._post("/v1/restricted-parties/screen",payload,kw.get("idempotency_key"),kw.get("payment_signature"),kw.get("request_body_digest"))
+    def continue_vendor_authorization(self,payload:Mapping[str,Any],**kw:Any)->dict[str,Any]: return self._post("/v1/vendors/authorizations/continue",payload,kw.get("idempotency_key"),kw.get("payment_signature"),kw.get("request_body_digest"))
+    def assess_invoice_authenticity_duplication(self,payload:Mapping[str,Any],**kw:Any)->dict[str,Any]: return self._post("/v1/gb/invoices/assess-authenticity-duplication",payload,kw.get("idempotency_key"),kw.get("payment_signature"),kw.get("request_body_digest"))
+    def verify_bank_account_ownership(self,payload:Mapping[str,Any],**kw:Any)->dict[str,Any]: return self._post("/v1/gb/bank-accounts/verify-ownership",payload,kw.get("idempotency_key"),kw.get("payment_signature"),kw.get("request_body_digest"))
+    def detect_company_material_change(self,payload:Mapping[str,Any],**kw:Any)->dict[str,Any]: return self._post("/v1/gb/companies/detect-material-change",payload,kw.get("idempotency_key"),kw.get("payment_signature"),kw.get("request_body_digest"))
+    def verify_business_licence(self,payload:Mapping[str,Any],**kw:Any)->dict[str,Any]: return self._post("/v1/gb/business-licences/verify",payload,kw.get("idempotency_key"),kw.get("payment_signature"),kw.get("request_body_digest"))
+    def verify_tax_registration(self,payload:Mapping[str,Any],**kw:Any)->dict[str,Any]: return self._post("/v1/gb/tax-registrations/verify",payload,kw.get("idempotency_key"),kw.get("payment_signature"),kw.get("request_body_digest"))
+    def verify_vat_registration(self,payload:Mapping[str,Any],**kw:Any)->dict[str,Any]: return self.verify_tax_registration(payload,**kw)
+    def validate_business_document(self,payload:Mapping[str,Any],**kw:Any)->dict[str,Any]: return self._post("/v1/gb/business-documents/validate",payload,kw.get("idempotency_key"),kw.get("payment_signature"),kw.get("request_body_digest"))
+    def verify_beneficial_ownership_control(self,payload:Mapping[str,Any],**kw:Any)->dict[str,Any]: return self._post("/v1/gb/beneficial-ownership-control/verify",payload,kw.get("idempotency_key"),kw.get("payment_signature"),kw.get("request_body_digest"))
+    def assess_source_evidence_freshness(self,payload:Mapping[str,Any],**kw:Any)->dict[str,Any]: return self._post("/v1/gb/evidence/assess-freshness",payload,kw.get("idempotency_key"),kw.get("payment_signature"),kw.get("request_body_digest"))
+    def verify_invoice_and_payee(self,payload:Mapping[str,Any],**kw:Any)->dict[str,Any]: return self._post("/v1/gb/solutions/invoice-payee-verification",payload,kw.get("idempotency_key"),kw.get("payment_signature"),kw.get("request_body_digest"))
+    def approve_supplier(self,payload:Mapping[str,Any],**kw:Any)->dict[str,Any]: return self._post("/v1/gb/suppliers/approve",payload,kw.get("idempotency_key"),kw.get("payment_signature"),kw.get("request_body_digest"))
+    def authorize_business_payment(self,payload:Mapping[str,Any],**kw:Any)->dict[str,Any]: return self._post("/v1/gb/payments/authorize",payload,kw.get("idempotency_key"),kw.get("payment_signature"),kw.get("request_body_digest"))
+    def create_company_capability_passport(self,payload:Mapping[str,Any],**kw:Any)->dict[str,Any]: return _validate_passport(self._t.request("POST","/v1/gb/company-passports",payload,idempotency_key=kw.get("idempotency_key")))
+    def get_company_capability_passport(self,passport_id:str)->dict[str,Any]: return _validate_passport(self._t.request("GET",f"/v1/gb/company-passports/{quote(passport_id,safe='')}"))
+    def get_company_capability_passport_version(self,passport_id:str,version:int)->dict[str,Any]: return _validate_passport(self._t.request("GET",f"/v1/gb/company-passports/{quote(passport_id,safe='')}/versions/{version}"))
+    def replay_company_capability_passport(self,passport_id:str,version:int)->dict[str,Any]: return self._t.request("GET",f"/v1/gb/company-passports/{quote(passport_id,safe='')}/replays/{version}")
+    def verify_company_capability_passport(self,passport_id:str)->dict[str,Any]: return self._t.request("GET",f"/v1/gb/company-passports/{quote(passport_id,safe='')}/verify")
+    def verify_company_capability_passport_version(self,passport_id:str,version:int)->dict[str,Any]: return self._t.request("GET",f"/v1/gb/company-passports/{quote(passport_id,safe='')}/versions/{version}/verify")
+    def update_company_capability_passport(self,passport_id:str,payload:Mapping[str,Any],**kw:Any)->dict[str,Any]: return _validate_passport(self._t.request("POST",f"/v1/gb/company-passports/{quote(passport_id,safe='')}/updates",payload,idempotency_key=kw.get("idempotency_key")))
+    def refresh_company_capability_passport(self,passport_id:str,payload:Mapping[str,Any],**kw:Any)->dict[str,Any]: return _validate_passport(self._t.request("POST",f"/v1/gb/company-passports/{quote(passport_id,safe='')}/refresh",payload,idempotency_key=kw.get("idempotency_key")))
+    def invalidate_company_capability_passport(self,passport_id:str,payload:Mapping[str,Any],**kw:Any)->dict[str,Any]: return _validate_passport(self._t.request("POST",f"/v1/gb/company-passports/{quote(passport_id,safe='')}/invalidate",payload,idempotency_key=kw.get("idempotency_key")))
+    def company_check(self,payload:Mapping[str,Any],**kw:Any)->dict[str,Any]: return self._post("/v1/gb/solutions/company-check",payload,kw.get("idempotency_key"),kw.get("payment_signature"),kw.get("request_body_digest"))
+    def supplier_approval(self,payload:Mapping[str,Any],**kw:Any)->dict[str,Any]: return self._post("/v1/gb/solutions/supplier-approval",payload,kw.get("idempotency_key"),kw.get("payment_signature"),kw.get("request_body_digest"))
+    def invoice_payee_verification(self,payload:Mapping[str,Any],**kw:Any)->dict[str,Any]: return self._post("/v1/gb/solutions/invoice-payee-verification",payload,kw.get("idempotency_key"),kw.get("payment_signature"),kw.get("request_body_digest"))
+    def payment_authorization(self,payload:Mapping[str,Any],**kw:Any)->dict[str,Any]: return self._post("/v1/gb/solutions/payment-authorization",payload,kw.get("idempotency_key"),kw.get("payment_signature"),kw.get("request_body_digest"))
+    def vendor_change_continuous_authorization(self,payload:Mapping[str,Any],**kw:Any)->dict[str,Any]: return self._post("/v1/gb/solutions/vendor-change-continuous-authorization",payload,kw.get("idempotency_key"),kw.get("payment_signature"),kw.get("request_body_digest"))
+    def replay(self,execution_id:str)->dict[str,Any]: return _validate_envelope(self._t.request("GET",f"/v1/gb/executions/{quote(execution_id,safe='')}"))
+    def consume_token(self,token:str,usage_id:str)->dict[str,Any]:
+        value=self._t.request("POST","/v1/gb/tokens/consume",{"token":token,"usage_id":usage_id})
+        if not isinstance(value.get("state"),str): raise OracleError("RESPONSE_SCHEMA_INVALID",502,value)
+        return value
+    async def aresolve_legal_entity(self,payload:Mapping[str,Any],**kw:Any)->dict[str,Any]: return await asyncio.to_thread(self.resolve_legal_entity,payload,**kw)
+    async def averify_company_status(self,payload:Mapping[str,Any],**kw:Any)->dict[str,Any]: return await asyncio.to_thread(self.verify_company_status,payload,**kw)
+    async def ascreen_restricted_party(self,payload:Mapping[str,Any],**kw:Any)->dict[str,Any]: return await asyncio.to_thread(self.screen_restricted_party,payload,**kw)
+    async def acontinue_vendor_authorization(self,payload:Mapping[str,Any],**kw:Any)->dict[str,Any]: return await asyncio.to_thread(self.continue_vendor_authorization,payload,**kw)
+    async def aassess_invoice_authenticity_duplication(self,payload:Mapping[str,Any],**kw:Any)->dict[str,Any]: return await asyncio.to_thread(self.assess_invoice_authenticity_duplication,payload,**kw)
+    async def averify_bank_account_ownership(self,payload:Mapping[str,Any],**kw:Any)->dict[str,Any]: return await asyncio.to_thread(self.verify_bank_account_ownership,payload,**kw)
+    async def adetect_company_material_change(self,payload:Mapping[str,Any],**kw:Any)->dict[str,Any]: return await asyncio.to_thread(self.detect_company_material_change,payload,**kw)
+    async def averify_business_licence(self,payload:Mapping[str,Any],**kw:Any)->dict[str,Any]: return await asyncio.to_thread(self.verify_business_licence,payload,**kw)
+    async def averify_vat_registration(self,payload:Mapping[str,Any],**kw:Any)->dict[str,Any]: return await asyncio.to_thread(self.verify_vat_registration,payload,**kw)
+    async def averify_tax_registration(self,payload:Mapping[str,Any],**kw:Any)->dict[str,Any]: return await asyncio.to_thread(self.verify_tax_registration,payload,**kw)
+    async def avalidate_business_document(self,payload:Mapping[str,Any],**kw:Any)->dict[str,Any]: return await asyncio.to_thread(self.validate_business_document,payload,**kw)
+    async def averify_beneficial_ownership_control(self,payload:Mapping[str,Any],**kw:Any)->dict[str,Any]: return await asyncio.to_thread(self.verify_beneficial_ownership_control,payload,**kw)
+    async def aassess_source_evidence_freshness(self,payload:Mapping[str,Any],**kw:Any)->dict[str,Any]: return await asyncio.to_thread(self.assess_source_evidence_freshness,payload,**kw)
+    async def averify_invoice_and_payee(self,payload:Mapping[str,Any],**kw:Any)->dict[str,Any]: return await asyncio.to_thread(self.verify_invoice_and_payee,payload,**kw)
+    async def aapprove_supplier(self,payload:Mapping[str,Any],**kw:Any)->dict[str,Any]: return await asyncio.to_thread(self.approve_supplier,payload,**kw)
+    async def aauthorize_business_payment(self,payload:Mapping[str,Any],**kw:Any)->dict[str,Any]: return await asyncio.to_thread(self.authorize_business_payment,payload,**kw)
+    async def acreate_company_capability_passport(self,payload:Mapping[str,Any],**kw:Any)->dict[str,Any]: return await asyncio.to_thread(self.create_company_capability_passport,payload,**kw)
+    async def aget_company_capability_passport(self,passport_id:str)->dict[str,Any]: return await asyncio.to_thread(self.get_company_capability_passport,passport_id)
+    async def aget_company_capability_passport_version(self,passport_id:str,version:int)->dict[str,Any]: return await asyncio.to_thread(self.get_company_capability_passport_version,passport_id,version)
+    async def areplay_company_capability_passport(self,passport_id:str,version:int)->dict[str,Any]: return await asyncio.to_thread(self.replay_company_capability_passport,passport_id,version)
+    async def averify_company_capability_passport(self,passport_id:str)->dict[str,Any]: return await asyncio.to_thread(self.verify_company_capability_passport,passport_id)
+    async def averify_company_capability_passport_version(self,passport_id:str,version:int)->dict[str,Any]: return await asyncio.to_thread(self.verify_company_capability_passport_version,passport_id,version)
+    async def aupdate_company_capability_passport(self,passport_id:str,payload:Mapping[str,Any],**kw:Any)->dict[str,Any]: return await asyncio.to_thread(self.update_company_capability_passport,passport_id,payload,**kw)
+    async def arefresh_company_capability_passport(self,passport_id:str,payload:Mapping[str,Any],**kw:Any)->dict[str,Any]: return await asyncio.to_thread(self.refresh_company_capability_passport,passport_id,payload,**kw)
+    async def ainvalidate_company_capability_passport(self,passport_id:str,payload:Mapping[str,Any],**kw:Any)->dict[str,Any]: return await asyncio.to_thread(self.invalidate_company_capability_passport,passport_id,payload,**kw)
+    async def areplay(self,execution_id:str)->dict[str,Any]: return await asyncio.to_thread(self.replay,execution_id)
+    async def aconsume_token(self,token:str,usage_id:str)->dict[str,Any]: return await asyncio.to_thread(self.consume_token,token,usage_id)
+
+class OracleClient:
+    def __init__(self,base_url:str,*,bearer_token:str|None=None,timeout:float=8,retries:int=2): self.transport=Transport(ClientOptions(base_url,bearer_token,timeout,retries)); self.uk=UkClient(self.transport)
+
+def verify_ed25519_token(token:str,public_key_pem:bytes,*,audience:str|None=None,now:int|None=None)->dict[str,Any]:
+    try:
+        from cryptography.hazmat.primitives import serialization
+        from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PublicKey
+    except ImportError as error: raise OracleError("CRYPTOGRAPHY_EXTRA_REQUIRED") from error
+    parts=token.split(".");
+    if len(parts)!=3 or len(token.encode())>8192: raise OracleError("TOKEN_MALFORMED")
+    header=_decode(parts[0]); claims=_decode(parts[1]);
+    if header.get("alg")!="EdDSA": raise OracleError("TOKEN_ALGORITHM_UNSUPPORTED")
+    key=serialization.load_pem_public_key(public_key_pem)
+    if not isinstance(key,Ed25519PublicKey): raise OracleError("TOKEN_KEY_INVALID")
+    try: key.verify(_b64(parts[2]),f"{parts[0]}.{parts[1]}".encode())
+    except Exception as error: raise OracleError("TOKEN_SIGNATURE_INVALID") from error
+    current=now or int(time.time())
+    if isinstance(claims.get("not_before"),int) and current<claims["not_before"]: raise OracleError("TOKEN_NOT_YET_VALID")
+    if isinstance(claims.get("expires_at"),int) and current>=claims["expires_at"]: raise OracleError("TOKEN_EXPIRED")
+    if audience is not None and claims.get("audience")!=audience: raise OracleError("TOKEN_AUDIENCE_MISMATCH")
+    return claims
+def _b64(value:str)->bytes: return base64.urlsafe_b64decode(value+"="*((4-len(value)%4)%4))
+def _decode(value:str)->dict[str,Any]:
+    try: return json.loads(_b64(value))
+    except Exception as error: raise OracleError("TOKEN_MALFORMED") from error
+def _json(raw:bytes)->dict[str,Any]:
+    try: value=json.loads(raw); return value if isinstance(value,dict) else {"value":value}
+    except Exception: return {}
+def _validate_envelope(value:dict[str,Any])->dict[str,Any]:
+    economic=value.get("economic_activity")
+    if not isinstance(value.get("schema_version"),str) or not isinstance(value.get("product_or_solution"),str) or value.get("decision") not in ("APPROVE","CONDITIONAL","REVIEW","BLOCK","RETRY","NO_DECISION") or not isinstance(economic,dict) or not isinstance(economic.get("charged"),bool) or not isinstance(economic.get("quote_created"),bool) or not isinstance(economic.get("settlement_created"),bool) or "result" not in value: raise OracleError("RESPONSE_SCHEMA_INVALID",502,value)
+    return value
+def _validate_passport(value:dict[str,Any])->dict[str,Any]:
+    if not isinstance(value.get("passport_id"),str) or not isinstance(value.get("passport_version"),int) or not isinstance(value.get("passport_digest"),str) or value.get("economic_mutations") != 0: raise OracleError("RESPONSE_SCHEMA_INVALID",502,value)
+    return value

cdo_oracle_sdk-0.1.0/src/cdo_oracle_sdk.egg-info/PKG-INFO

@@ -0,0 +1,25 @@
+Metadata-Version: 2.4
+Name: cdo-oracle-sdk
+Version: 0.1.0
+Summary: Python SDK for the RunOnProof decision API
+Author-email: RunOnProof <institucional@aureumone.io>
+License-Expression: MIT
+Project-URL: Homepage, https://runonproof.com
+Project-URL: Documentation, https://docs.runonproof.com/docs
+Project-URL: Repository, https://github.com/runonproof/cdo
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Provides-Extra: crypto
+Requires-Dist: cryptography>=45; extra == "crypto"
+
+# RunOnProof Python SDK
+
+`cdo-oracle-sdk` is the supported Python client for the RunOnProof decision API.
+It exposes synchronous and asynchronous clients for the Brazil and United Kingdom
+decision products, including company checks, supplier approval, invoice and payee
+verification, payment authorization, vendor changes, and Company Passport operations.
+
+The client is fail-closed: it preserves evidence, correlation and idempotency fields,
+uses bounded network operations, and does not sign transactions or settle payments.
+See the [RunOnProof documentation](https://docs.runonproof.com/docs) for API setup and
+credential handling.

cdo_oracle_sdk-0.1.0/src/cdo_oracle_sdk.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+README.md
+pyproject.toml
+src/cdo_oracle/__init__.py
+src/cdo_oracle/client.py
+src/cdo_oracle_sdk.egg-info/PKG-INFO
+src/cdo_oracle_sdk.egg-info/SOURCES.txt
+src/cdo_oracle_sdk.egg-info/dependency_links.txt
+src/cdo_oracle_sdk.egg-info/requires.txt
+src/cdo_oracle_sdk.egg-info/top_level.txt

cdo_oracle_sdk-0.1.0/src/cdo_oracle_sdk.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

cdo_oracle_sdk-0.1.0/src/cdo_oracle_sdk.egg-info/requires.txt

@@ -0,0 +1,3 @@
+
+[crypto]
+cryptography>=45

cdo_oracle_sdk-0.1.0/src/cdo_oracle_sdk.egg-info/top_level.txt

@@ -0,0 +1 @@
+cdo_oracle