certapi 0.4.0__tar.gz → 0.4.2__tar.gz

{certapi-0.4.0 → certapi-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: certapi
-Version: 0.4.0
+Version: 0.4.2
 Summary: Python Package for managing keys, request SSL certificates from ACME.
 Home-page: https://github.com/mesudip/certapi
 Author: Sudip Bhattarai
@@ -33,7 +33,7 @@ import json
 from certapi import FileSystemChallengeStore, FilesystemKeyStore, CertAuthority
 
 key_store = FilesystemKeyStore("data")
-challenge_store = FileSystemChallengeStore("./acme-challenges")  # this should be where your web server hosts the .well-known/acme-challenges.
+challenge_store = FileSystemChallengeStore("./acme-challenges")  # this should be where your web server hosts the .well-known/
 
 certAuthority = CertAuthority(challenge_store, key_store)
 certAuthority.setup()

{certapi-0.4.0 → certapi-0.4.2}/README.md

@@ -20,7 +20,7 @@ import json
 from certapi import FileSystemChallengeStore, FilesystemKeyStore, CertAuthority
 
 key_store = FilesystemKeyStore("data")
-challenge_store = FileSystemChallengeStore("./acme-challenges")  # this should be where your web server hosts the .well-known/acme-challenges.
+challenge_store = FileSystemChallengeStore("./acme-challenges")  # this should be where your web server hosts the .well-known/
 
 certAuthority = CertAuthority(challenge_store, key_store)
 certAuthority.setup()

{certapi-0.4.0 → certapi-0.4.2}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="certapi",
-    version="0.4.0",
+    version="0.4.2",
     packages=find_packages(where="src"),
     package_dir={"": "src"},
     install_requires=[

certapi-0.4.2/src/certapi/__init__.py

@@ -0,0 +1,23 @@
+from .acme.Acme import Acme, Order, AcmeNetworkError, AcmeHttpError, Challenge
+from .manager.acme_cert_manager import AcmeCertManager
+from .http.types import CertificateResponse, IssuedCert
+
+from .crypto import (
+    Certificate,
+    CertificateSigningRequest,
+    CertificateSigningRequestBuilder,
+    Key,
+    Ed25519Key,
+    ECDSAKey,
+    Ed25519PrivateKey,
+    EllipticCurvePrivateKey,
+)
+from .keystore import FileSystemKeystore, SqliteKeyStore, PostgresKeyStore, KeyStore
+from .challenge_store import (
+    ChallengeStore,
+    InMemoryChallengeStore,
+    FileSystemChallengeStore,
+    CloudflareChallengeStore,
+    DigitalOceanChallengeStore,
+)
+from .issuers import SelfCertIssuer

{certapi-0.4.0 → certapi-0.4.2}/src/certapi/acme/Acme.py

@@ -9,13 +9,14 @@ from cryptography.hazmat.primitives.asymmetric.rsa import RSAPrivateKey
 from cryptography.x509 import CertificateSigningRequest, Certificate
 from certapi.crypto import crypto
 import requests
-from certapi.crypto import sign, digest_sha256, csr_to_der, jwk, get_algorithm_name, sign_for_jws,Key
+from certapi.crypto import sign, digest_sha256, csr_to_der, jwk, get_algorithm_name, sign_for_jws, Key
 from certapi.util import b64_encode, b64_string
 from .AcmeError import *
 from .http import *
 from .Challenge import Challenge
 from .Order import Order
 
+
 class Acme:
 
     URL_STAGING = "https://acme-staging-v02.api.letsencrypt.org/directory"
@@ -23,7 +24,7 @@ class Acme:
 
     def __init__(self, account_key: Union[RSAPrivateKey, EllipticCurvePrivateKey | Key], url=URL_STAGING):
         self.account_key = account_key.key if isinstance(account_key, Key) else account_key
-        
+
         # json web key format for public key
         self.jwk = jwk(self.account_key)
         print(self.jwk)

{certapi-0.4.0 → certapi-0.4.2}/src/certapi/acme/Challenge.py

@@ -1,4 +1,3 @@
-
 import json
 from typing import Literal, Union
 
@@ -7,7 +6,8 @@ import requests
 from certapi.util import b64_encode, b64_string
 from certapi.crypto import digest_sha256
 from .AcmeError import *
-from .http import post,get
+from .http import post, get
+
 
 class Challenge:
     def __init__(self, auth_url, data, acme):
@@ -15,7 +15,7 @@ class Challenge:
         self._acme = acme
         self._data = data
         challenge = self.get_challenge()
-        self.token:str = challenge["token"]
+        self.token: str = challenge["token"]
         self.verified = challenge["status"] == "valid"
         self.domain = data["identifier"]["value"]  # Add domain attribute
 
@@ -25,24 +25,21 @@ class Challenge:
 
         self.url = "http://{0}/.well-known/acme-challenge/{1}".format(data["identifier"]["value"], self.token)
 
-    def as_key_value(self,type:Literal["http-01", "dns-01", "tls-alpn-01"]=None):
-        challenge=self.get_challenge(type)
+    def as_key_value(self, type: Literal["http-01", "dns-01", "tls-alpn-01"] = None):
+        challenge = self.get_challenge(type)
 
         if challenge["type"] == "dns-01":
             key = f"_acme-challenge.{self.domain}"
             value = b64_string(digest_sha256(self.authorization_key.encode("utf8")))
         else:
-            key =  self.token
-            value =  self.authorization_key
-        
-        return (key,value)
+            key = self.token
+            value = self.authorization_key
 
+        return (key, value)
 
-    def verify(self, type:Literal["http-01", "dns-01", "tls-alpn-01"]=None) -> bool:
+    def verify(self, type: Literal["http-01", "dns-01", "tls-alpn-01"] = None) -> bool:
         if not self.verified:
-            response = self._acme._signed_req(
-                self.get_challenge(type)["url"], {}, step="Verify Challenge", throw=False
-            )
+            response = self._acme._signed_req(self.get_challenge(type)["url"], {}, step="Verify Challenge", throw=False)
             if response.status_code == 200 and response.json()["status"] == "valid":
                 self.verified = True
                 return True
@@ -73,9 +70,9 @@ class Challenge:
             else:
                 return False
 
-    def get_challenge(self, type:Literal["http-01", "dns-01", "tls-alpn-01"]=None):
+    def get_challenge(self, type: Literal["http-01", "dns-01", "tls-alpn-01"] = None):
         challenges = self._data["challenges"]
-        def_key= type if type is not None else "http-01"
+        def_key = type if type is not None else "http-01"
         for method in challenges:
             if method["type"] == def_key:
                 return method

{certapi-0.4.0 → certapi-0.4.2}/src/certapi/acme/Order.py

@@ -1,10 +1,11 @@
 from typing import List, Tuple
-from certapi.crypto import crypto,csr_to_der
+from certapi.crypto import crypto, csr_to_der
 from certapi.util import b64_string
-from cryptography.x509 import CertificateSigningRequest,Certificate
+from cryptography.x509 import CertificateSigningRequest, Certificate
 from .Challenge import *
 from .http import get
 
+
 class Order:
     def __init__(self, url, data, challenges, acme):
         self.url = url

{certapi-0.4.0 → certapi-0.4.2}/src/certapi/acme/__init__.py

@@ -1,4 +1,4 @@
 from .Challenge import Challenge
 from .AcmeError import *
 from .Acme import Acme
-from .Order import Order
+from .Order import Order

{certapi-0.4.0 → certapi-0.4.2}/src/certapi/acme/http.py

@@ -1,7 +1,7 @@
-
 import requests
 from .AcmeError import *
 
+
 def request(method, step: str, url: str, json=None, headers=None, throw=True) -> requests.Response:
     res = None
     try:
@@ -53,4 +53,3 @@ def post(step: str, url: str, json=None, headers=None, throw=True) -> requests.R
 
 def get(step: str, url) -> requests.Response:
     return request("GET", step, url)
-

{certapi-0.4.0 → certapi-0.4.2}/src/certapi/challenge_store/ChallengeStore.py

@@ -7,6 +7,7 @@ class ChallengeStore(ABC):
     """
     Abstract base class for a challenge store.
     """
+
     @abstractmethod
     def supports_domain(self, domain: str) -> bool:
         pass
@@ -22,6 +23,7 @@ class ChallengeStore(ABC):
     @abstractmethod
     def delete_challenge(self, key: str, domain: str = None):
         pass
+
     def store_details():
         return {
             "name": "Abstract Challenge Store",
@@ -31,4 +33,4 @@ class ChallengeStore(ABC):
         raise NotImplementedError("Must implement `__iter__` method.")
 
     def __len__(self):
-        raise NotImplementedError("Must implement `__len__` method.")
+        raise NotImplementedError("Must implement `__len__` method.")

{certapi-0.4.0 → certapi-0.4.2}/src/certapi/challenge_store/__init__.py

@@ -2,7 +2,8 @@ from .ChallengeStore import ChallengeStore
 from .InmemoryChallengeStore import InMemoryChallengeStore
 import os
 from .FileSystemChallengeStore import FileSystemChallengeStore
-from .dns import CloudflareChallengeStore,DigitalOceanChallengeStore
+from .dns import CloudflareChallengeStore, DigitalOceanChallengeStore
+
 
 def get_challenge_store():
     """
@@ -21,5 +22,3 @@ def get_challenge_store():
         return FileSystemChallengeStore(directory)
     else:
         raise ValueError(f"Unknown CHALLENGE_STORE_TYPE: {store_type}")
-
-

{certapi-0.4.0 → certapi-0.4.2}/src/certapi/challenge_store/dns/__init__.py

@@ -1,2 +1,2 @@
 from .digitalocean.digitalocean_challenge_store import DigitalOceanChallengeStore
-from .cloudflare.cloudflare_challenge_store import CloudflareChallengeStore
+from .cloudflare.cloudflare_challenge_store import CloudflareChallengeStore

certapi-0.4.2/src/certapi/challenge_store/dns/cloudflare/cloudflare_challenge_store.py

@@ -0,0 +1,59 @@
+import os
+import time
+from collections.abc import MutableMapping
+from ...ChallengeStore import ChallengeStore
+from .cloudflare_client import Cloudflare
+
+
+class CloudflareChallengeStore(ChallengeStore):
+    def __init__(self, api_key: str = None):
+        self.cloudflare = Cloudflare(api_key)
+        self.challenges_map = {}
+
+    def supports_domain(self, domain: str) -> bool:
+        """
+        Checks if the Cloudflare account has access to the given domain (or its base domain)
+        as a registered zone.
+        """
+        try:
+            self.cloudflare.determine_registered_domain(domain)
+            return True
+        except Exception:
+            return False
+
+    def save_challenge(self, key: str, value: str, domain=None):
+        # key example: _acme-challenge.sub.example.com
+        # value example: ACME_CHALLENGE_TOKEN
+        base_domain = self.cloudflare.determine_registered_domain(domain)
+
+        record_id = self.cloudflare.create_record(name=key, data=value, domain=base_domain)
+        self.challenges_map[key] = record_id
+        print(f"CloudflareChallengeStore: Saved challenge for {key} with record ID {record_id}")
+        time.sleep(10)  # wait for dns propagation. it may not be immediate
+
+    def get_challenge(self, key: str, domain: str) -> str:
+        base_domain = self.cloudflare.determine_registered_domain(domain)
+        records = self.cloudflare.list_txt_records(base_domain, name_filter=key)
+        for record in records:
+            if record["name"] == key:
+                return record["content"]
+        return None  # Return None if not found, as per ChallengeStore's __getitem__ behavior
+
+    def delete_challenge(self, key: str, domain: str):
+        if key not in self.challenges_map:
+            raise KeyError(f"Challenge {key} not found in store (no record_id stored).")
+
+        record_id = self.challenges_map[key]
+        base_domain = self.cloudflare.determine_registered_domain(domain)
+        self.cloudflare.delete_record(record=record_id, domain=base_domain)
+        del self.challenges_map[key]
+        print(f"CloudflareChallengeStore: Deleted challenge for {key} with record ID {record_id}")
+
+    def __iter__(self):
+        # This is tricky as we can't easily iterate all challenges across all domains
+        # If the user wants a full API-driven iteration, they need to clarify how to get all domains.
+        return iter(self.challenges_map)
+
+    def __len__(self):
+        # Similar to __iter__, this will count challenges managed by this store instance.
+        return len(self.challenges_map)

certapi-0.4.2/src/certapi/challenge_store/dns/cloudflare/cloudflare_client.py

@@ -0,0 +1,138 @@
+import json
+import time
+from os import getenv
+from urllib.request import urlopen, Request
+
+
+class Cloudflare(object):
+    name = "cloudflare"
+
+    def __init__(self, api_key: str):
+        self.token = api_key
+        self.api = "https://api.cloudflare.com/client/v4"
+        if not self.token:
+            self.token = getenv("CLOUDFLARE_API_KEY")
+            if not self.token:
+                raise Exception("CLOUDFLARE_API_KEY not found in environment")
+
+        self._zones_cache = None
+        self._zones_cache_time = 0  # Unix timestamp of last cache update
+
+    def _cloudflare_headers(self):
+        return {"Content-Type": "application/json", "Authorization": "Bearer " + self.token}
+
+    def _get_zones(self):
+        """Fetch and cache Cloudflare zones"""
+        # Cache for 1 day (86400 seconds)
+        if self._zones_cache and (time.time() - self._zones_cache_time) < 86400:
+            return self._zones_cache
+
+        request_headers = self._cloudflare_headers()
+        api_url = "{0}/zones?per_page=50".format(self.api)
+        response = urlopen(Request(api_url, headers=request_headers))
+        if response.getcode() != 200:
+            raise Exception(json.loads(response.read().decode("utf8")))
+
+        zones = json.loads(response.read().decode("utf8"))["result"]
+        self._zones_cache = zones
+        self._zones_cache_time = time.time()
+        return zones
+
+    def _get_zone_id(self, domain):
+        """Determine Cloudflare Zone ID for a given domain"""
+        zones = self._get_zones()
+        for zone in zones:
+            if zone["name"] == domain:
+                return zone["id"]
+        raise Exception("No Cloudflare zone found for domain: {0}".format(domain))
+
+    def determine_registered_domain(self, domain: str) -> str:
+        """
+        Determine the registered domain in Cloudflare for a given (sub)domain.
+        This method iterates through parts of the domain to find a matching Cloudflare zone.
+        """
+        parts = domain.split(".")
+        err = None
+        for i in range(len(parts)):
+            potential_domain = ".".join(parts[i:])
+            try:
+                self._get_zone_id(potential_domain)
+                return potential_domain
+            except Exception as e:
+                err = e
+                continue
+        if err:
+            raise err
+        else:
+            raise Exception("Could not determine Cloudflare registered domain for: {0}".format(domain))
+
+    def list_txt_records(self, domain: str, name_filter: str = None) -> list:
+        """
+        Lists TXT records for a given domain, optionally filtered by name.
+        Returns a list of dictionaries, each representing a TXT record.
+        """
+        registered_domain = self.determine_registered_domain(domain)
+        zone_id = self._get_zone_id(registered_domain)
+        api_url = f"{self.api}/zones/{zone_id}/dns_records?type=TXT"
+        if name_filter:
+            api_url += f"&name={name_filter}"
+
+        request_headers = self._cloudflare_headers()
+        response = urlopen(Request(api_url, headers=request_headers))
+
+        if response.getcode() != 200:
+            raise Exception(json.loads(response.read().decode("utf8")))
+
+        result = json.loads(response.read().decode("utf8"))
+        if not result.get("success"):
+            raise Exception(result.get("errors", "Unknown error listing TXT records"))
+
+        return result["result"]
+
+    def create_record(self, name, data, domain):
+        """
+        Create DNS record
+        Params:
+            name, string, record name (e.g., _acme-challenge.example.com)
+            data, string, record data (e.g., ACME challenge token)
+            domain, string, dns domain (e.g., example.com) - This will be used to determine the registered zone.
+        Return:
+            record_id, string, created record id
+        """
+        registered_domain = self.determine_registered_domain(domain)
+        zone_id = self._get_zone_id(registered_domain)
+        api_url = "{0}/zones/{1}/dns_records".format(self.api, zone_id)
+        request_headers = self._cloudflare_headers()
+        request_data = {
+            "type": "TXT",
+            "name": name,
+            "content": data,
+            "ttl": 120,  # Cloudflare minimum TTL for TXT is 120 seconds
+            "proxied": False,
+        }
+        response = urlopen(Request(api_url, data=json.dumps(request_data).encode("utf8"), headers=request_headers))
+
+        if response.getcode() != 200:
+            raise Exception(json.loads(response.read().decode("utf8")))
+        result = response.read().decode("utf8")
+        print("Cloudflare create record", name, result)
+        return json.loads(result)["result"]["id"]
+
+    def delete_record(self, record, domain):
+        """
+        Delete DNS record
+        Params:
+            record, string, record id number
+            domain, string, dns domain - This will be used to determine the registered zone.
+        """
+        registered_domain = self.determine_registered_domain(domain)
+        zone_id = self._get_zone_id(registered_domain)
+        api_url = "{0}/zones/{1}/dns_records/{2}".format(self.api, zone_id, record)
+        request_headers = self._cloudflare_headers()
+        request = Request(api_url, headers=request_headers)
+        request.get_method = lambda: "DELETE"
+        response = urlopen(request)
+        result = response.read().decode("utf8")
+        print(f"Delete dns record [{response.getcode()}]", result)
+        if response.getcode() != 200:
+            raise Exception(json.loads(response.read().decode("utf8")))

certapi-0.4.2/src/certapi/challenge_store/dns/digitalocean/digitalocean_challenge_store.py

@@ -0,0 +1,57 @@
+import os
+from collections.abc import MutableMapping
+from ...ChallengeStore import ChallengeStore
+from .digitalocean_client import DigitalOcean
+
+
+class DigitalOceanChallengeStore(ChallengeStore):
+    def __init__(self, api_key: str = None):
+        self.digitalocean = DigitalOcean(api_key)
+        self.challenges_map = {}  # Stores key: record_id (needed for deletion)
+
+    def supports_domain(self, domain: str) -> bool:
+        """
+        Checks if the DigitalOcean account has access to the given domain (or its base domain)
+        as a registered zone.
+        """
+        try:
+            self.digitalocean.determine_domain(domain)
+            return True
+        except Exception:
+            return False
+
+    def save_challenge(self, key: str, value: str, domain=None):
+        # key example: _acme-challenge.sub.example.com
+        # value example: ACME_CHALLENGE_TOKEN
+        base_domain = self.digitalocean.determine_domain(domain)
+
+        record_id = self.digitalocean.create_record(name=key, data=value, domain=base_domain)
+        self.challenges_map[key] = record_id
+        print(f"DigitalOceanChallengeStore: Saved challenge for {key} with record ID {record_id}")
+
+    def get_challenge(self, key: str, domain: str) -> str:
+        base_domain = self.digitalocean.determine_domain(domain)
+        records = self.digitalocean.list_records(base_domain, name_filter=key)
+        for record in records:
+            if record["name"] == key:
+                return record["data"]  # DigitalOcean API returns 'data' for TXT record content
+        return None  # Return None if not found, as per ChallengeStore's __getitem__ behavior
+
+    def delete_challenge(self, key: str, domain: str):
+        if key not in self.challenges_map:
+            raise KeyError(f"Challenge {key} not found in store (no record_id stored).")
+
+        record_id = self.challenges_map[key]
+        base_domain = self.digitalocean.determine_domain(domain)
+        self.digitalocean.delete_record(record=record_id, domain=base_domain)
+        del self.challenges_map[key]
+        print(f"DigitalOceanChallengeStore: Deleted challenge for {key} with record ID {record_id}")
+
+    def __iter__(self):
+        # This is tricky as we can't easily iterate all challenges across all domains
+        # If the user wants a full API-driven iteration, they need to clarify how to get all domains.
+        return iter(self.challenges_map)
+
+    def __len__(self):
+        # Similar to __iter__, this will count challenges managed by this store instance.
+        return len(self.challenges_map)

certapi-0.4.2/src/certapi/challenge_store/dns/digitalocean/digitalocean_client.py

@@ -0,0 +1,85 @@
+import json
+from os import getenv
+
+from urllib.request import urlopen, Request  # Python 3
+
+
+class DigitalOcean(object):
+    def __init__(self, api_key: str = None):
+        self.token = api_key
+        self.api = "https://api.digitalocean.com/v2/domains"
+        if not self.token:
+            self.token = getenv("DIGITALOCEAN_API_KEY")
+            if not self.token:
+                raise Exception("DIGITALOCEAN_API_KEY not found in environment")
+
+    def determine_domain(self, domain):
+        """Determine registered domain in API"""
+        request_headers = {"Content-Type": "application/json", "Authorization": "Bearer {0}".format(self.token)}
+        response = urlopen(Request(self.api, headers=request_headers))
+        if response.getcode() != 200:
+            raise Exception(json.loads(response.read().decode("utf8")))
+        domains = json.loads(response.read().decode("utf8"))["domains"]
+        for d in domains:
+            if d["name"] in domain:
+                return d["name"]
+
+    def create_record(self, name, data, domain):
+        """
+        Create DNS record
+        Params:
+            name, string, record name
+            data, string, record data
+            domain, string, dns domain
+        Return:
+            record_id, int, created record id
+        """
+        registered_domain = self.determine_domain(domain)
+        api = self.api + "/" + registered_domain + "/records"
+        request_headers = {"Content-Type": "application/json", "Authorization": "Bearer {0}".format(self.token)}
+        request_data = {"type": "TXT", "ttl": 300, "name": name, "data": data}
+        response = urlopen(Request(api, data=json.dumps(request_data).encode("utf8"), headers=request_headers))
+        if response.getcode() != 201:
+            raise Exception(json.loads(response.read().decode("utf8")))
+        return json.loads(response.read().decode("utf8"))["domain_record"]["id"]
+
+    def delete_record(self, record, domain):
+        """
+        Delete DNS record
+        Params:
+            record, int, record id number
+            domain, string, dns domain
+        """
+        registered_domain = self.determine_domain(domain)
+        api = self.api + "/" + registered_domain + "/records/" + str(record)
+        request_headers = {"Content-Type": "application/json", "Authorization": "Bearer {0}".format(self.token)}
+        request = Request(api, data=json.dumps({}).encode("utf8"), headers=request_headers)
+        request.get_method = lambda: "DELETE"
+        response = urlopen(request)
+        if response.getcode() != 204:
+            raise Exception(json.loads(response.read().decode("utf8")))
+
+    def list_records(self, domain, name_filter=None):
+        """
+        List DNS records for a domain, optionally filtered by name.
+        Params:
+            domain, string, dns domain
+            name_filter, string, optional filter for record name
+        Return:
+            records, list of dicts, matching DNS records
+        """
+        registered_domain = self.determine_domain(domain)
+        api = self.api + "/" + registered_domain + "/records"
+        request_headers = {"Content-Type": "application/json", "Authorization": "Bearer {0}".format(self.token)}
+        response = urlopen(Request(api, headers=request_headers))
+        if response.getcode() != 200:
+            raise Exception(json.loads(response.read().decode("utf8")))
+
+        all_records = json.loads(response.read().decode("utf8"))["domain_records"]
+
+        if name_filter:
+            filtered_records = [r for r in all_records if r["name"] == name_filter and r["type"] == "TXT"]
+        else:
+            filtered_records = [r for r in all_records if r["type"] == "TXT"]
+
+        return filtered_records

{certapi-0.4.0 → certapi-0.4.2}/src/certapi/client/cert_manager_client.py

@@ -2,6 +2,7 @@ import requests
 from typing import List, Union, Dict, Optional, Any
 from certapi.http.types import CertificateResponse, IssuedCert
 
+
 class CertManagerClient:
     def __init__(self, base_url: str):
         self.base_url = base_url
@@ -11,8 +12,15 @@ class CertManagerClient:
         response.raise_for_status()
         return response.json()
 
-    def _post(self, path: str, data: Optional[Union[Dict[str, Any], str]] = None, headers: Optional[Dict[str, str]] = None) -> Any:
-        response = requests.post(f"{self.base_url}{path}", json=data if isinstance(data, dict) else None, data=data if isinstance(data, str) else None, headers=headers)
+    def _post(
+        self, path: str, data: Optional[Union[Dict[str, Any], str]] = None, headers: Optional[Dict[str, str]] = None
+    ) -> Any:
+        response = requests.post(
+            f"{self.base_url}{path}",
+            json=data if isinstance(data, dict) else None,
+            data=data if isinstance(data, str) else None,
+            headers=headers,
+        )
         response.raise_for_status()
         return response.json()
 
@@ -32,17 +40,24 @@ class CertManagerClient:
             "key_type": key_type,
             "expiry_days": expiry_days,
         }
-        if country: params["country"] = country
-        if state: params["state"] = state
-        if locality: params["locality"] = locality
-        if organization: params["organization"] = organization
-        if user_id: params["user_id"] = user_id
+        if country:
+            params["country"] = country
+        if state:
+            params["state"] = state
+        if locality:
+            params["locality"] = locality
+        if organization:
+            params["organization"] = organization
+        if user_id:
+            params["user_id"] = user_id
 
         data = self._get("/obtain", params=params)
         return CertificateResponse.from_json(data)
 
     def sign_csr(self, csr_pem: str) -> str:
-        response = requests.post(f"{self.base_url}/sign_csr", data=csr_pem, headers={'Content-Type': 'application/x-pem-file'})
+        response = requests.post(
+            f"{self.base_url}/sign_csr", data=csr_pem, headers={"Content-Type": "application/x-pem-file"}
+        )
         response.raise_for_status()
         return response.text
 
@@ -88,11 +103,14 @@ class CertManagerClient:
                 return None
             raise
 
-    def save_cert(self, private_key_id: Union[int, str], cert_pem: str, domains: List[str], name: Optional[str] = None) -> Dict[str, Any]:
+    def save_cert(
+        self, private_key_id: Union[int, str], cert_pem: str, domains: List[str], name: Optional[str] = None
+    ) -> Dict[str, Any]:
         data = {
             "private_key_id": private_key_id,
             "cert": cert_pem,
             "domains": domains,
         }
-        if name: data["name"] = name
-        return self._post("/certs", data=data)
+        if name:
+            data["name"] = name
+        return self._post("/certs", data=data)

certapi-0.4.2/src/certapi/crypto/__init__.py

@@ -0,0 +1,2 @@
+from .crypto import *
+from .crypto_classes import *