restpki-ng-python-client 0.9.0__py3-none-any.whl

restpki_ng_python_client/restpki_ng_client.py

@@ -0,0 +1,458 @@
+""" 
+User defined, this is not included in the openAPI generation package
+This client intends to center all requests and provide a better name for some of the operations
+To help the user to make a more informed decision
+it is a facade class, which hides all the apis and other implementation problems
+"""
+
+import hashlib
+from io import BufferedReader, BytesIO
+import io
+import os
+import ssl
+from typing import Dict, List
+from restpki_ng_python_client.rest import RESTResponse
+from restpki_ng_python_client.configuration import Configuration
+from restpki_ng_python_client.api_client import ApiClient
+from restpki_ng_python_client.api import *
+from restpki_ng_python_client.models import *
+from restpki_ng_python_client.utils import Utils
+
+
+class RestPkiClient:
+    
+    def __init__(self, endpoint: str, api_key: str):
+        self.endpoint = endpoint
+        self.api_key = api_key
+
+        self._config = Configuration(
+            host=self.endpoint,
+            api_key=self.api_key,
+            username=None,
+            api_key_prefix=None,
+            password=None,
+            server_variables=None,
+            server_index=None,
+            server_operation_index=None,
+            server_operation_variables=None,
+            ssl_ca_cert=None)
+        self._config.verify_ssl = False
+
+        # api_key_dict = {'x-api-key': f'Bearer {self.api_key}'}
+
+        self._apiClient = ApiClient(configuration=self._config)
+        self._apiClient.user_agent = 'RestPkiClient/Python/Lib/Beta'
+        
+        self._apiClient.default_headers['Authorization'] = "Bearer " + self.api_key
+        self._apiClient.default_headers['x-api-key'] = "Bearer " + self.api_key
+        
+        # Upload stuff
+        self.__multipart_upload_threshold = 5 * 1024 * 1024  # 5 MB
+
+        # Todo: create one client with the endpoint and apikey for each of the routes
+        # AppKeys29 API
+        # self._app_keys_29_api = ApplicationKeysController29Api(api_client=self._apiClient)
+        # Applications API
+        # self._apps_api = ApplicationsApi(api_client=self._apiClient)
+        # Applications Controller 29 API
+        # self._app_ctrl_29_api = ApplicationsController29Api(api_client=self._apiClient)
+        # Authentication API
+        self._auth_api = AuthenticationApi(api_client=self._apiClient)
+        # Cades Signature API
+        self._cades_sig_api = CadesSignatureApi(api_client=self._apiClient)
+        # Certificates API
+        # self._certs_api = CertificatesApi(api_client=self._apiClient)
+        # DocumentKeys API
+        self._doc_keys_api = DocumentKeysApi(api_client=self._apiClient)
+        # Documents API
+        self._docs_api = DocumentsApi(api_client=self._apiClient)
+        # Pades Signature API
+        self._pades_sig_api = PadesSignatureApi(api_client=self._apiClient)
+        # Pades visual positioning presets API
+        self._pades_visual_pos_pres_api = PadesVisualPositioningPresetsApi(
+            api_client=self._apiClient)
+        # PDF API
+        self._pdf_api = PdfApi(api_client=self._apiClient)
+        # Pending Signatures API
+        # self._pending_sigs_api = PendingSignaturesApi(api_client=self._apiClient)
+        # Signature API
+        self._sig_api = SignatureApi(api_client=self._apiClient)
+        # Signature Inspection API
+        self._sig_insp_api = SignatureInspectionApi(api_client=self._apiClient)
+        # Signature Sessions API
+        self._sig_ses_api = SignatureSessionsApi(api_client=self._apiClient)
+        # Timestamp API
+        self._ts_api = TimestampApi(api_client=self._apiClient)
+        # Upload API
+        self._upload_api = UploadApi(api_client=self._apiClient)
+        # XML Signature API
+        self._xml_sig_api = XmlSignatureApi(api_client=self._apiClient)
+
+    # # ApplicationsController`29 Manage applications
+    # def get_application_controller(self, q, limit, offset, cursor, order, name) -> SubscriptionAccessModelRolesRootRolesApplicationModelPaginatedSearchResponse:
+    #     self._app_ctrl_29_api.api_applications_get(q, limit, offset, cursor, order, name)
+
+    # def create_application_controller(self, request: AuthorizationDataRootAuthorizationDataRolesRootRolesApplicationData) -> SubscriptionAccessModelRolesRootRolesApplicationModel:
+    #     self._app_ctrl_29_api.api_applications_post(request)
+
+    # def get_application_controller_by_id(self, id) -> SubscriptionAccessModelRolesRootRolesApplicationModel:
+    #     self._app_ctrl_29_api.api_applications_id_get(id)
+
+    # def delete_application_controller_by_id(self, id):
+    #     self._app_ctrl_29_api.api_applications_id_delete(id)
+
+    # def check_for_application_name_availability(self, name) -> bool:
+    #     self._app_ctrl_29_api.api_applications_name_availability_get(name)
+
+    # ApplicationKeysController`29
+
+    # def create_application_keys(self, app_id, request: CreateApplicationApiKeyRequest) -> CreateApplicationApiKeyResponse:
+    #     self._app_keys_29_api.api_applications_app_id_api_keys_post(app_id, request)
+
+    # Applications
+
+    # Configures a set of metadata values to be added to each document created by the application
+
+    def add_document_metadata_set(self, id, request: Dict[str, List]) -> Dict[str, List[str]]:
+        return self._apps_api.api_applications_id_default_document_metadata_put(id, request)
+
+    # Returns the set of metadata values that is currently added for documents created by a given application
+    def document_metadata_get(self, id) -> Dict[str, List[str]]:
+        return self._apps_api.api_applications_id_default_document_metadata_get(id)
+
+    # Applications
+
+    # Prepares for a certificate authentication
+    def start_authentication_v2(self, request: PrepareAuthenticationRequest) -> PrepareAuthenticationResponse:
+        return self._auth_api.api_v2_authentication_post(prepare_authentication_request=request)
+
+    # Completes a certificate authentication
+    def complete_authentication_v2(self, request: CompleteAuthenticationRequest) -> CompleteAuthenticationResponse:
+        return self._auth_api.api_v2_authentication_completion_post(complete_authentication_request=request)
+
+    def create_authentications(self, request: AuthenticationsPostRequest) -> AuthenticationsPostResponse:
+        return self._auth_api.api_authentications_post(authentications_post_request=request)
+
+    def finalize_authentication_token(self, token) -> AuthenticationPostResponse:
+        return self._auth_api.api_authentications_token_finalize_post(token=token)
+
+    def finalize_authentication_token(self, request: AuthenticationsPostSignedBytesRequest) -> AuthenticationsPostSignedBytesResponse:
+        return self._auth_api.api_authentications_token_signed_bytes_post(authentications_post_signed_bytes_request=request)
+
+    def authentication_get_nonce(self) -> AuthenticationGetResponse:
+        return self._auth_api.api_authentication_get()
+
+    def start_authentication(self, request: AuthenticationsPostRequest) -> AuthenticationPostResponse:
+        return self._auth_api.api_authentication_post(authentication_post_request=request)
+
+    # CadesSignature
+
+    def create_cades_signature_v2(self, request: CadesSignaturePostRequestV1) -> CadesSignaturePostResponse:
+        return self._cades_sig_api.api_cades_signatures_post(cades_signature_post_request_v1=request)
+
+    def create_cades_signature_v2(self, request: CadesSignaturePostRequestV2) -> CadesSignaturePostResponse:
+        return self._cades_sig_api.api_v2_cades_signatures_post(cades_signature_post_request_v2=request)
+
+    def create_cades_signature_v3(self, request: CadesSignaturePostRequestV3) -> CadesSignaturePostResponse:
+        return self._cades_sig_api.api_v3_cades_signatures_post(cades_signature_post_request_v3=request)
+
+    def create_cades_signatures_with_token_signed_bytes_v1(self, token, request: CadesSignaturePostSignedBytesRequest) -> CadesSignaturePostSignedBytesResponse:
+        return self._cades_sig_api.api_cades_signatures_token_signed_bytes_post(token=token, cades_signature_post_signed_bytes_request=request)
+
+    def finish_cades_signatures_with_token(self, token,) -> CadesSignaturePostSignedBytesResponse:
+        return self._cades_sig_api.api_cades_signatures_token_finalize_post(token=token)
+
+    def create_cades_signatures_with_token_signed_bytes_v2(self, token, request: CompleteSignatureRequest) -> SignatureResultModel:
+        return self._cades_sig_api.api_v2_cades_signatures_token_signed_bytes_post(token=token, complete_signature_request=request)
+
+    def create_cades_signature_required_hashes(self, request: FileModel) -> List[DigestAlgorithms]:
+        return self._cades_sig_api.api_cades_signatures_required_hashes_post(file_model=request)
+
+    def open_cades_signature(self, request: OpenCadesSignatureRequestModel) -> CadesSignatureModel:
+        return self._cades_sig_api.api_cades_signatures_open_post(open_cades_signature_request_model=request)
+
+    # Certificates
+
+    # Retrieves information about a X.509 certificate previously used to sign some document
+    # def retrieve_certificate_info(self, certificate_thumbprint_sha256: str, fill_pem_encoded: bool, fill_encoded: bool) -> CertificateFullModel:
+    #     self._certs_api.api_certificates_thumbprint_sha256_get(certificate_thumbprint_sha256, fill_pem_encoded, fill_encoded)
+
+    # Document Keys
+
+    # Allocates a document key to be used later on a document signature
+    def allocate_document_key(self, request: AllocateDocumentKeyRequest) -> DocumentKeyModel:
+        return self._doc_keys_api.api_document_keys_post(allocate_document_key_request=request)
+
+    # Allocates a batch of document keys to be used later on document signatures
+    def allocate_batch_document_keys(self, request: AllocateDocumentKeyBatchRequest) -> List[DocumentKeyModel]:
+        return self._doc_keys_api.api_document_keys_batch_post(allocate_document_key_batch_request=request)
+
+    # Queries documents by key
+    def query_documents_by_key(self, key: str) -> DocumentKeyQueryResponse:
+        return self._doc_keys_api.api_document_keys_key_get(key=key)
+
+    # Queries unused document keys
+    def query_unused_document_keys(self, metadata_name: str, metadata_value: str) -> List[DocumentKeySummary]:
+        return self._doc_keys_api.api_document_keys_unused_get(metadata_name=metadata_name, metadata_value=metadata_value)
+
+    # Documents
+
+    # Retrieves document details
+    def retrieve_document_by_id(self, id: str) -> DocumentModel:
+        return self._docs_api.api_documents_id_get(id=id)
+
+    # Retrieves the full information about each of a document's signers
+    def retrieve_signers_info_in_document_by_id(self, id: str) -> List[SignerModel]:
+        return self._docs_api.api_documents_id_signers_get(id=id)
+
+    # Retrieves the full information about each of a document's signers
+    def retrieve_document_details_by_key(self, key: str) -> DocumentQueryResponse:
+        return self._docs_api.api_documents_keys_key_get(key=key)
+
+    # PadesSignature
+
+    def start_pades_signature(self, request: PadesSignaturePostRequestV1) -> PadesSignaturePostResponse:
+        return self._pades_sig_api.api_pades_signatures_post(pades_signature_post_request_v1=request)
+
+    def start_pades_signature_v2(self, request: PadesSignaturePostRequestV2) -> PadesSignaturePostResponse:
+        return self._pades_sig_api.api_v2_pades_signatures_post(pades_signature_post_request_v2=request)
+
+    def complete_pades_signature_with_token_and_signed_bytes(self, token: str, request: PadesSignaturePostSignedBytesRequest) -> PadesSignaturePostSignedBytesResponse:
+        return self._pades_sig_api.api_pades_signatures_token_signed_bytes_post(token=token, pades_signature_post_signed_bytes_request=request)
+
+    def complete_pades_signature_with_token(self, token) -> PadesSignaturePostSignedBytesResponse:
+        return self._pades_sig_api.api_pades_signatures_token_finalize_post(token=token)
+
+    def complete_pades_signature_with_token_and_signed_bytes_v2(self, token, request: CompleteSignatureRequest) -> SignatureResultModel:
+        return self._pades_sig_api.api_v2_pades_signatures_token_signed_bytes_post(complete_signature_request=request, token=token)
+
+    def open_pades_signature(self, request: OpenSignatureRequestModel) -> PadesSignatureModel:
+        return self._pades_sig_api.api_pades_signatures_open_post(open_signature_request_model=request)
+
+    # PadesVisualPositioningPresets
+
+    def get_footnotes_pades_visual_positioning_presets(self, page_number, rows) -> PadesVisualPositioningModel:
+        return self._pades_visual_pos_pres_api.api_pades_visual_positioning_presets_footnote_get(page_number=page_number, rows=rows)
+
+    def get_footnotes_pades_visual_positioning_presets_bottom_up(self, page_number, rows) -> PadesVisualPositioningModel:
+        return self._pades_visual_pos_pres_api.api_pades_visual_positioning_presets_footnote_bottom_up_get(page_number=page_number, rows=rows)
+
+    def get_footnotes_pades_visual_positioning_presets_new_page(self) -> PadesVisualPositioningModel:
+        return self._pades_visual_pos_pres_api.api_pades_visual_positioning_presets_new_page_get()
+
+    # Pdf
+
+    def pdf_add_marks(self, request: PdfAddMarksRequest) -> PdfAddMarksResponse:
+        return self._pdf_api.api_pdf_add_marks_post(pdf_add_marks_request=request)
+
+    # Signature
+
+    def start_signature(self, request: PrepareSignatureRequest) -> PrepareSignatureResponse:
+        return self._sig_api.api_signature_post(prepare_signature_request=request)
+
+    def complete_signature(self, request: CompleteSignatureRequestV2) -> DocumentModel:
+        return self._sig_api.api_signature_completion_post(complete_signature_request_v2=request)
+
+    # Signature Inspection
+
+    # Inspects a signed file, returning information about its signers and metadata about the corresponding document (if signed on this instance)
+    def inspect_signed_file(self, request: InspectSignatureRequest) -> InspectSignatureResponse:
+        return self._sig_insp_api.api_signature_inspection_put(inspect_signature_request=request)
+
+    # SignatureSessions
+
+    # Retrieves a signature session's details
+    def retrieve_signature_session_details_by_id(self, id) -> SignatureSessionModel:
+        return self._sig_ses_api.api_signature_sessions_id_get(id=id)
+
+    # Creates a signature session
+    def create_signature_session(self, request: CreateSignatureSessionRequest) -> CreateSignatureSessionResponse:
+        return self._sig_ses_api.api_signature_sessions_post(create_signature_session_request=request)
+
+    # Waits for the completion of a signature session
+    def wait_for_completion_signature_session_by_id(self, id):
+        return self._sig_ses_api.api_signature_sessions_id_when_completed_get(id=id)
+
+    # Timestamp
+
+    def issue_timestamp_plan_with_identifier(self, identifier, request: DigestAlgorithmAndValueModel) -> TimestampIssueResponse:
+        return self._ts_api.api_timestamp_plans_identifier_issue_post(identifier=identifier, digest_algorithm_and_value_model=request)
+
+    def create_timestamp_plan_with_identifier(self, identifier, request: DigestAlgorithmAndValueModel) -> TimestampIssueResponse:
+        return self._ts_api.api_timestamp_plans_identifier_issue_post(identifier=identifier, digest_algorithm_and_value_model=request)
+
+    # Upload
+
+    # public methods
+    def upload_file_multipart(self, file_desc: BufferedReader | BytesIO | str):
+        blob_token = self._upload_multipart(file_desc)
+        return blob_token
+    
+    def upload_file_plain(self, file_path: str, file_desc: BufferedReader | BytesIO | str):
+        blob_token = self._perform_plain_uploads(file_path, file_desc)
+        return blob_token
+
+    def upload_file_from_path(self, path):
+        # Check if the file exists
+        if not os.path.exists(path):
+            print(f"Error: File not found at {path}")
+            return False
+        else:
+            with open(path, 'rb') as file_desc:
+                isMultipart = self._isBiggerThanThreshold(file_desc)
+                if isMultipart:
+                    return self.upload_file_multipart(file_desc)
+                else:
+                    return self.upload_file_plain(path, file_desc)
+
+
+    def upload_file_from_raw(self, content_raw):
+        stream = BytesIO()
+        stream.write(content_raw)
+        stream.seek(0, 0)
+        
+        isMultipart = self._isBiggerThanThreshold(content_raw)
+        if isMultipart:
+            return self.upload_file_multipart(content_raw)
+        else:
+            return self.upload_file_plain(content_raw)
+        
+    def get_file_from_url(self, url: str) -> RESTResponse:
+        return self._apiClient.rest_client.request('GET', url, self._apiClient.default_headers)
+        
+    # END public methods
+
+    # private methods
+    def _upload_multipart(self, file_desc):
+
+        # Begin the upload
+        response = self._perform_multipart_uploads()
+        blob_token = response.blob_token
+        part_size = response.part_size
+
+        # begin_url = self.__endpoint_url + 'Api/MultipartUploads'
+        # begin_response = requests.post(begin_url,
+        #                                headers=self.get_request_headers())
+        # self._check_response('GET', begin_url, begin_response)
+
+        # blob_token = begin_response.json().get('blobToken')
+        # blob_uri = "Api/MultipartUploads/%s" % blob_token
+        # part_size = begin_response.json().get('partSize')
+
+        # Read the file part by part
+
+        part_e_tags = []
+        part_number = 0
+
+        # Return to the start of the stream.
+        file_desc.seek(0, 0)
+        while True:
+            buffer = file_desc.read(part_size)
+            if buffer is None or len(buffer) == 0:
+                # Reached end-of-file.
+                break
+            part_hash = hashlib.md5(buffer)
+            part_digest = Utils._base64_url_safe_encode_string(part_hash.digest())
+            # self._apiClient.default_headers['Content-MD5'] = Utils.encodeBase64(part_hash.digest())
+            # self._apiClient.default_headers['Content-Type'] = 'application/octet-stream'
+            # part_url = '%s/%s' % (blob_uri, part_number)
+            # response = requests.post(self.__endpoint_url + part_url,
+            #                          data=buffer,
+            #                          headers=headers)
+            response = self._perform_multipart_uploads_with_token_and_part_number(blob_token, part_number, part_digest)
+            # self._check_response('POST', part_url, response)
+            e_tag = response.headers['ETag']
+            part_e_tags.append(e_tag)
+            part_number += 1
+
+        # Finish upload
+
+        # end_request = {
+        #     'partETags': part_e_tags,
+        #     'completeMD5': None
+        # }
+            
+        end_request = MultipartUploadEndRequest(
+            part_e_tags=part_e_tags,
+            complete_md5=None
+        )
+
+        if self.__multipart_upload_double_check:
+            file_desc.seek(0, 0)
+            md5 = hashlib.md5(file_desc.read())
+            digest = md5.digest()
+            end_request.complete_md5 = Utils._base64_encode_string(digest)
+        
+        # finish_url = self.__endpoint_url + blob_uri
+        # finish_response = requests.post(finish_url,
+        #                                 data=json.dumps(end_request),
+        #                                 headers=self.get_request_headers())
+        response = self._perform_multipart_uploads_with_token(blob_token)
+        # self._check_response('POST', finish_url, finish_response)
+
+        return response
+
+    def _perform_plain_uploads(self, file_path, file) -> FileReferenceModel:
+        return self._upload_api.api_plain_uploads_post(file_path, file)
+
+    def _perform_multipart_uploads(self) -> MultipartUploadBeginResponse:
+        return self._upload_api.api_multipart_uploads_post()
+
+    def _perform_multipart_uploads_with_token_and_part_number(self, token, part_number, part_digest):
+        return self._upload_api.api_multipart_uploads_token_part_number_post(token, part_number, part_digest)
+
+    def _perform_multipart_uploads_with_token(self, token):
+        return self._upload_api.api_multipart_uploads_token_post(token=token)
+    
+    def _isBiggerThanThreshold(self, file) -> bool:
+        if isinstance(file, str):  # Check if file is a file path
+            return self._checkSizeForFilePath(file)
+        elif isinstance(file, io.BufferedReader):  # Check if file is a ReadableBuffer
+            return self._checkSizeForRawContent(file)
+        else: 
+            print(f"Error: Unsupported input type ({type(file)}).")
+    
+    def _checkSizeForFilePath(self, file_path) -> bool:
+        # Get the file size in bytes
+        file_size_bytes = os.path.getsize(file_path)
+
+        # Check if the file size is below the limit
+        if file_size_bytes <= self.__multipart_upload_threshold:
+            return False
+        else:
+            return True
+    
+    def _checkSizeForRawContent(self, buffer) -> bool:
+        # Get the file size in bytes
+        buffer.seek(0, io.SEEK_END)
+        content_size_bytes = buffer.tell()
+        buffer.seek(0, io.SEEK_SET)
+
+        # Check if the file size is below the limit
+        if content_size_bytes <= self.__multipart_upload_threshold:
+            return False
+        else:
+            return True
+
+    # END private methods
+
+    # END Upload
+    # XMLSignature
+
+    def create_full_xml_signature(self, request: FullXmlSignaturePostRequest) -> XmlSignaturePostResponse:
+        return self._xml_sig_api.api_xml_signatures_full_xml_signature_post(full_xml_signature_post_request=request)
+
+    def create_element_xml_signature(self, request: XmlElementSignaturePostRequest) -> XmlSignatureResponseModel:
+        return self._xml_sig_api.api_xml_signatures_xml_element_signature_post(xml_element_signature_post_request=request)
+
+    def complete_xml_signature_with_token_and_signed_bytes(self, token, request: XmlSignaturePostSignedBytesRequest) -> XmlSignaturePostSignedBytesResponse:
+        return self._xml_sig_api.api_xml_signatures_token_signed_bytes_post(token=token, xml_signature_post_signed_bytes_request=request)
+
+    def complete_xml_signature_with_token(self, token) -> XmlSignaturePostSignedBytesResponse:
+        return self._xml_sig_api.api_xml_signatures_token_finalize_post(token=token)
+
+    def open_xml_signature(self, request: OpenXmlSignatureRequestModel) -> List[XmlSignatureModel]:
+        return self._xml_sig_api.api_xml_signatures_open_post(open_xml_signature_request_model=request)
+
+    def open_xml_signature_v2(self, request: OpenXmlSignatureRequestModel) -> XmlSignatureResponseModel:
+        return self._xml_sig_api.api_v2_xml_signatures_open_post(open_xml_signature_request_model=request)

restpki_ng_python_client/standard_signature_policies.py

@@ -0,0 +1,24 @@
+class StandardSignaturePolicies:
+    PADES_BASIC = '78d20b33-014d-440e-ad07-929f05d00cdf'
+    PADES_BASIC_WITH_PKI_BRAZIL_CERTS = '3fec800c-366c-49bf-82c5-2e72154e70f6'
+    PADES_T_WITH_PKI_BRAZIL_CERTS = '6a39aeea-a2d0-4754-bf8c-19da15296ddb'
+    PKI_BRAZIL_PADES_ADR_BASICA = '531d5012-4c0d-4b6f-89e8-ebdcc605d7c2'
+    PKI_BRAZIL_PADES_ADR_TEMPO = '10f0d9a5-a0a9-42e9-9523-e181ce05a25b'
+
+    CADES_BES = 'a4522485-c9e5-46c3-950b-0d6e951e17d1'
+    CADES_BES_WITH_SIGNING_TIME_AND_NO_CRLS =\
+        '8108539d-c137-4f45-a1f2-de5305bc0a37'
+    PKI_BRAZIL_CADES_ADR_BASICA = '3ddd8001-1672-4eb5-a4a2-6e32b17ddc46'
+    PKI_BRAZIL_CADES_ADR_TEMPO = 'a5332ad1-d105-447c-a4bb-b5d02177e439'
+    PKI_BRAZIL_CADES_ADR_COMPLETA = '30d881e7-924a-4a14-b5cc-d5a1717d92f6'
+
+    XML_DSIG_BASIC = '2bb5d8c9-49ba-4c62-8104-8141f6459d08'
+    XADES_BES = '1beba282-d1b6-4458-8e46-bd8ad6800b54'
+    PKI_BRAZIL_XADES_ADR_BASICA = '1cf5db62-58b6-40ba-88a3-d41bada9b621'
+    PKI_BRAZIL_XADES_ADR_TEMPO = '5aa2e0af-5269-43b0-8d45-f4ef52921f04'
+    NFE_PADRAO_NACIONAL = 'a3c24251-d43a-4ba4-b25d-ee8e2ab24f06'
+
+    def __init__(self):
+        pass
+
+__all__ = ['StandardSignaturePolicies']

restpki_ng_python_client/utils.py

@@ -0,0 +1,80 @@
+import base64
+import binascii
+from io import BytesIO, FileIO
+
+from restpki_ng_python_client.models.file_model import FileModel
+
+class Utils:
+    def _base64_encode_string(value):
+        """
+
+        This method is just a wrapper that handle the incompatibility between the
+        standard_b64encode() method on versions 2 and 3 of Python. On Python 2, a
+        string is returned, but on Python 3, a bytes-class instance is returned.
+
+        """
+        value_base64 = base64.standard_b64encode(value)
+        if type(value_base64) is str:
+            return value_base64
+        elif type(value_base64) is bytes or type(value_base64) is bytearray:
+            return value_base64.decode('ascii')
+        return None
+    def _base64_url_safe_encode_string(value):
+        """
+
+        This method is just a wrapper that handle the incompatibility between the
+        standard_b64encode() method on versions 2 and 3 of Python. On Python 2, a
+        string is returned, but on Python 3, a bytes-class instance is returned.
+
+        """
+        value_base64 = base64.urlsafe_b64encode(value)
+        if type(value_base64) is str:
+            return value_base64
+        elif type(value_base64) is bytes or type(value_base64) is bytearray:
+            return value_base64.decode('ascii')
+        return None
+
+
+    def _base64_decode(value):
+        if value is None:
+            raise Exception('The provided value is not valid')
+        try:
+            raw = base64.standard_b64decode(value)
+        except (TypeError, binascii.Error):
+            raise Exception('The provided certificate is not Base64-encoded')
+        return raw
+
+
+    def _copy_stream(src, dst, offset=0, from_where=0, buff_size=4096):
+        # Position source ont he required position.
+        dst.seek(offset, from_where)
+        while True:
+            buff = src.read(buff_size)
+            if not buff:
+                break
+            dst.write(buff)
+
+
+    def _get_raw_stream(content):
+        stream = BytesIO(content)
+        stream.seek(0, 0)
+        return stream
+    
+    def write_to_file(file: FileModel, path: str,
+        client = None, offset=0, from_where=0, 
+        buff_size=4096):
+        content_base64 = file.content if file.content != None else None
+        content_raw = Utils._base64_decode(content_base64)\
+            if content_base64 is not None else None
+        with open(path, 'wb') as f_out:
+            if content_raw is not None:
+                f_in = BytesIO(content_raw)
+                Utils._copy_stream(f_in, f_out, offset, from_where, buff_size)
+                f_in.close()
+            else:
+                if file.url != None or file.url != '' or client != None or client.endpoint != '':
+                    req_url = '%s%s' % (client.endpoint, file.url)
+                    res = client.get_file_from_url(req_url)
+                    for chunk in res.data\
+                            .iter_content(buff_size):
+                        f_out.write(chunk)

restpki_ng_python_client-0.9.0.dist-info/METADATA

@@ -0,0 +1,16 @@
+Metadata-Version: 2.1
+Name: restpki_ng_python_client
+Version: 0.9.0
+Summary: Rest PKI Core API
+Home-page: 
+Author: OpenAPI Generator community
+Author-email: team@openapitools.org
+Keywords: OpenAPI,OpenAPI-Generator,Rest PKI Core API
+Description-Content-Type: text/markdown
+Requires-Dist: urllib3 <2.1.0,>=1.24.3
+Requires-Dist: python-dateutil
+Requires-Dist: pydantic >=2
+Requires-Dist: typing-extensions >=4.7.1
+
+    &lt;b&gt;&lt;i&gt;Para Português, &lt;a href&#x3D;\&quot;https://docs.lacunasoftware.com/pt-br/articles/rest-pki/core/integration/get-started\&quot;&gt;clique aqui&lt;/a&gt;&lt;/i&gt;&lt;/b&gt;  &lt;p&gt;   &lt;a href&#x3D;\&quot;https://docs.lacunasoftware.com/en-us/articles/rest-pki/core/\&quot;&gt;Rest PKI Core&lt;/a&gt; is an upcoming version of   &lt;a href&#x3D;\&quot;https://docs.lacunasoftware.com/en-us/articles/rest-pki/\&quot;&gt;Rest PKI&lt;/a&gt; that will have extended compatibility with environments and databases.  &lt;/p&gt;  &lt;p&gt;   In addition to Windows Server (which is already supported by Rest PKI), Rest PKI Core will also run on &lt;b&gt;Linux&lt;/b&gt; (Debian- and RedHat-based distributions)   and on &lt;b&gt;Docker&lt;/b&gt;. As for database servers, in addition to SQL Server, &lt;b&gt;PostgreSQL&lt;/b&gt; will also be supported.  &lt;/p&gt;  &lt;p&gt;   &lt;b&gt;Before getting started, see the integration overview on the &lt;a href&#x3D;\&quot;https://docs.lacunasoftware.com/en-us/articles/rest-pki/core/integration/\&quot;&gt;Integration Guide&lt;/a&gt;&lt;/b&gt;  &lt;/p&gt;  &lt;p&gt;   For questions regarding the usage of this API, please reach us at &lt;a href&#x3D;\&quot;https://lacuna.help/\&quot;&gt;lacuna.help&lt;/a&gt;  &lt;/p&gt;    &lt;h2&gt;Parameters&lt;/h2&gt;  &lt;p&gt;   You will need the following parameters:  &lt;/p&gt;  &lt;ul&gt;   &lt;li&gt;&lt;b&gt;Endpoint&lt;/b&gt;: address of the Rest PKI Core instance that will be used&lt;/li&gt;   &lt;li&gt;&lt;b&gt;API Key&lt;/b&gt;: authorization key for using the API&lt;/li&gt;  &lt;/ul&gt;  &lt;p&gt;   The &lt;span class&#x3D;\&quot;model\&quot;&gt;endpoint&lt;/span&gt; must be prefixed to all relative URLs mentioned here. As for the &lt;span class&#x3D;\&quot;model\&quot;&gt;API Key&lt;/span&gt;, see how to use it below.  &lt;/p&gt;    &lt;h2&gt;Authentication&lt;/h2&gt;  &lt;p&gt;   The API key must be sent on the &lt;span class&#x3D;\&quot;model\&quot;&gt;X-Api-Key&lt;/span&gt; header on each request:  &lt;/p&gt;    &lt;!-- unfortunately, class \&quot;example microlight\&quot; doesn&#39;t seem to work here --&gt;  &lt;pre style&#x3D;\&quot;font-size: 12px; padding: 10px; border-radius: 4px; background: #41444e; font-weight: 600; color: #fff;\&quot;&gt;  X-Api-Key: yourapp|xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx  &lt;/pre&gt;    &lt;h2&gt;HTTP Codes&lt;/h2&gt;    &lt;p&gt;   The APIs will return the following HTTP codes:  &lt;/p&gt;    &lt;table&gt;   &lt;thead&gt;    &lt;tr&gt;     &lt;th&gt;Code&lt;/th&gt;     &lt;th&gt;Description&lt;/th&gt;    &lt;/tr&gt;   &lt;/thead&gt;   &lt;tbody&gt;    &lt;tr&gt;     &lt;td&gt;&lt;strong class&#x3D;\&quot;model-title\&quot;&gt;200 (OK)&lt;/strong&gt;&lt;/td&gt;     &lt;td&gt;Request processed successfully. The response is different for each API, please refer to the operation&#39;s documentation&lt;/td&gt;    &lt;/tr&gt;    &lt;tr&gt;     &lt;td&gt;&lt;strong class&#x3D;\&quot;model-title\&quot;&gt;400 (Bad Request)&lt;/strong&gt;&lt;/td&gt;     &lt;td&gt;Syntax error. For instance, when a required field was not provided&lt;/td&gt;    &lt;/tr&gt;    &lt;tr&gt;     &lt;td&gt;&lt;strong class&#x3D;\&quot;model-title\&quot;&gt;401 (Unauthorized)&lt;/strong&gt;&lt;/td&gt;     &lt;td&gt;API key not provided or invalid&lt;/td&gt;    &lt;/tr&gt;    &lt;tr&gt;     &lt;td&gt;&lt;strong class&#x3D;\&quot;model-title\&quot;&gt;403 (Forbidden)&lt;/strong&gt;&lt;/td&gt;     &lt;td&gt;API key is valid, but the application has insufficient permissions to complete the requested operation&lt;/td&gt;    &lt;/tr&gt;    &lt;tr&gt;     &lt;td&gt;&lt;strong class&#x3D;\&quot;model-title\&quot;&gt;422 (Unprocessable Entity)&lt;/strong&gt;&lt;/td&gt;     &lt;td&gt;API error. The response body is an &lt;a href&#x3D;\&quot;#model-ErrorModelV2\&quot; class&#x3D;\&quot;model\&quot;&gt;ErrorModelV2&lt;/a&gt;    &lt;/tr&gt;    &lt;tr&gt;     &lt;td&gt;&lt;strong class&#x3D;\&quot;model-title\&quot;&gt;500 (Internal Server Error)&lt;/strong&gt;&lt;/td&gt;     &lt;td&gt;An unexpected error occurred. The &lt;span class&#x3D;\&quot;model\&quot;&gt;exceptionCode&lt;/span&gt; contained on the response body may be of help for our support team during diagnostic.&lt;/td&gt;    &lt;/tr&gt;   &lt;/tbody&gt;  &lt;/table&gt;    &lt;h3&gt;Error Codes&lt;/h3&gt;    &lt;p&gt;   Some of the error codes returned in the &lt;span class&#x3D;\&quot;model\&quot;&gt;code&lt;/span&gt; field of an &lt;a href&#x3D;\&quot;#model-ErrorModelV2\&quot; class&#x3D;\&quot;model\&quot;&gt;ErrorModelV2&lt;/a&gt;   (body of responses with HTTP status code 422) are provided below*:  &lt;/p&gt;    &lt;table&gt;   &lt;thead&gt;    &lt;tr&gt;     &lt;th&gt;Code&lt;/th&gt;     &lt;th&gt;Description&lt;/th&gt;    &lt;/tr&gt;   &lt;/thead&gt;   &lt;tbody&gt;    &lt;tr&gt;     &lt;td class&#x3D;\&quot;model\&quot;&gt;DocumentNotFound&lt;/td&gt;     &lt;td&gt;A referenced document was not found (check the document ID)&lt;/td&gt;    &lt;/tr&gt;    &lt;tr&gt;     &lt;td class&#x3D;\&quot;model\&quot;&gt;SecurityContextNotFound&lt;/td&gt;     &lt;td&gt;A referenced security context was not found (check the security context ID)&lt;/td&gt;    &lt;/tr&gt;    &lt;tr&gt;     &lt;td class&#x3D;\&quot;model\&quot;&gt;SignatureSessionNotFound&lt;/td&gt;     &lt;td&gt;A referenced signature session was not found (check the signature session ID)&lt;/td&gt;    &lt;/tr&gt;    &lt;tr&gt;     &lt;td class&#x3D;\&quot;model\&quot;&gt;BadSignatureSessionOperation&lt;/td&gt;     &lt;td&gt;The operation is invalid for the current signature session or document status. For instance, trying to await the session&#39;s completion if it is still &lt;span class&#x3D;\&quot;model\&quot;&gt;Pending&lt;/span&gt; results in this error&lt;/td&gt;    &lt;/tr&gt;    &lt;tr&gt;     &lt;td class&#x3D;\&quot;model\&quot;&gt;BackgroundProcessing&lt;/td&gt;     &lt;td&gt;The operation cannot be completed at this time because the resource is being processed in background&lt;/td&gt;    &lt;/tr&gt;    &lt;tr&gt;     &lt;td class&#x3D;\&quot;model\&quot;&gt;SignatureSessionTokenRequired&lt;/td&gt;     &lt;td&gt;The signature session token was not passed on the &lt;span class&#x3D;\&quot;model\&quot;&gt;X-Signature-Session-Token&lt;/span&gt; request header&lt;/td&gt;    &lt;/tr&gt;    &lt;tr&gt;     &lt;td class&#x3D;\&quot;model\&quot;&gt;BadSignatureSessionToken&lt;/td&gt;     &lt;td&gt;An invalid signature session token was passed on the &lt;span class&#x3D;\&quot;model\&quot;&gt;X-Signature-Session-Token&lt;/span&gt; request header. Check your application for possible corruption of the session token, which may contain characters &lt;span class&#x3D;\&quot;code\&quot;&gt;-&lt;/span&gt; (hyphen) and &lt;span class&#x3D;\&quot;code\&quot;&gt;_&lt;/span&gt; (underscore)&lt;/td&gt;    &lt;/tr&gt;    &lt;tr&gt;     &lt;td class&#x3D;\&quot;model\&quot;&gt;ExpiredSignatureSessionToken&lt;/td&gt;     &lt;td&gt;An expired signature session token was passed on the &lt;span class&#x3D;\&quot;model\&quot;&gt;X-Signature-Session-Token&lt;/span&gt; request header. Signature session tokens are normally valid for 4 hours.&lt;/td&gt;    &lt;/tr&gt;   &lt;/tbody&gt;  &lt;/table&gt;    &lt;p style&#x3D;\&quot;font-size: 0.9em\&quot;&gt;   *The codes shown above are the most common error codes. Nonetheless, this list is not comprehensive. New codes may be added anytime without previous warning.  &lt;/p&gt;    &lt;h2&gt;Culture / Internationalization (i18n)&lt;/h2&gt;  &lt;p&gt;The &lt;span class&#x3D;\&quot;model\&quot;&gt;Accept-Language&lt;/span&gt; request header is observed by this API. The following cultures are supported:&lt;/p&gt;  &lt;ul&gt;   &lt;li&gt;&lt;span class&#x3D;\&quot;code\&quot;&gt;en-US&lt;/span&gt; (or simply &lt;span class&#x3D;\&quot;code\&quot;&gt;en&lt;/span&gt;)&lt;/li&gt;   &lt;li&gt;&lt;span class&#x3D;\&quot;code\&quot;&gt;pt-BR&lt;/span&gt; (or simply &lt;span class&#x3D;\&quot;code\&quot;&gt;pt&lt;/span&gt;)&lt;/li&gt;  &lt;/ul&gt;  &lt;p&gt;&lt;i&gt;Notice: error messages are not affected by this header and therefore should not be displayed to users, being better suited for logging.&lt;/i&gt;&lt;/p&gt;  
+