pybiolib 0.2.951__py3-none-any.whl → 1.2.1890__py3-none-any.whl

biolib/cli_utils.py

@@ -1,273 +0,0 @@
-import os
-import shutil
-import sys
-import platform
-import tempfile
-import time
-from pathlib import Path
-from typing import Tuple
-from zipfile import ZipFile
-from termcolor import colored
-
-import yaml
-
-from biolib.biolib_api_client import AppVersionOnJob, Module, FilesMapping
-from biolib.validators.validate_app_version import validate_app_version  # type: ignore
-from biolib.validators.validate_argument import validate_argument  # type: ignore
-from biolib.validators.validate_module import validate_module  # type: ignore
-from biolib.biolib_errors import BioLibError
-from biolib.biolib_logging import logger
-from biolib.typing_utils import Dict, List
-
-
-class BiolibValidationError(Exception):
-    pass
-
-
-def bl_colored(string, colour):
-    # The colors does not seem to play nice with Windows PowerShell terminal
-    if platform.system() == 'Windows':
-        return string
-    else:
-        return colored(string, colour)
-
-
-def validate_and_get_args(args):
-    if args is None:
-        args = []
-
-    if isinstance(args, str):
-        args = list(filter(lambda p: p != '', args.split(' ')))
-
-    if not isinstance(args, list):
-        raise Exception('The given input arguments must be list or str')
-
-    return args
-
-
-def get_files_dict_and_file_args(files, args):
-    if files is None:
-        files = []
-        # TODO: Figure out how to make this slightly less error prone
-        for idx, arg in enumerate(args):
-            if not arg.startswith('/'):
-                arg = f'{os.getcwd()}/{arg}'
-
-            arg = Path(arg)
-            if arg.is_file():
-                files.append(arg)
-                # Make sure that arg is only the filename
-                args[idx] = arg.parts[-1]
-
-    files_dict = {}
-    for file_path in files:
-        file = open(file_path, 'rb')
-        path = '/' + file_path.parts[-1]
-
-        files_dict[path] = file.read()
-        file.close()
-
-    return files_dict, args
-
-
-def validate_and_get_app_path(provided_app_path):
-    if provided_app_path.startswith('/'):
-        app_path = Path(provided_app_path)
-    else:
-        app_path = Path(os.getcwd()) / provided_app_path
-
-    if not app_path.exists():
-        print(f'ERROR: Could not find path {app_path}')
-        sys.exit(1)
-
-    if not app_path.is_dir():
-        print(f'ERROR: Path {app_path} is not a directory')
-        sys.exit(1)
-
-    return app_path
-
-
-def get_yaml_data(app_path):
-    try:
-        yaml_file = open(f'{app_path}/.biolib/config.yml', 'r', encoding='utf-8')
-
-    except Exception as error:  # pylint: disable=broad-except
-        raise BioLibError(f'Could not open the biolib config file at {app_path}/.biolib/config.yml') from error
-
-    try:
-        yaml_data = yaml.safe_load(yaml_file)
-
-    except Exception as error:  # pylint: disable=broad-except
-        raise BioLibError(f'Could not parse {app_path}/.biolib/config.yml. Please make sure it is valid YAML') \
-            from error
-
-    return yaml_data
-
-
-def validate_arguments(yaml_data):
-    error_dict = {'arguments': {}}
-    # Arguments are optional
-    if 'arguments' in yaml_data:
-        for argument in yaml_data['arguments']:
-            argument_errors = validate_argument(argument)
-            if argument_errors:
-                error_dict['arguments'].update(argument_errors)
-
-    # Just return empty dict if we have no errors
-    if error_dict['arguments']:
-        return error_dict
-    else:
-        return {}
-
-
-def validate_and_get_biolib_yaml_version(yaml_data, error_dict):
-    if not 'biolib_version' in yaml_data.keys():
-        error_dict['config_yml']['biolib_version'] = ['Your config file is missing the biolib_version field.']
-        print_errors(error_dict)
-        sys.exit(1)
-    else:
-        biolib_version = yaml_data['biolib_version']
-
-    if biolib_version not in (1, 2):
-        error_dict['config_yml']['biolib_version'] = \
-            [f'Biolib version can only be either 1 or 2 for now, your version is {biolib_version}.']
-        print_errors(error_dict)
-        sys.exit(1)
-
-    return biolib_version
-
-
-def validate_modules(yaml_data, biolib_yaml_version):
-    error_dict = {'modules': {}}
-    if 'modules' in yaml_data:
-        for name, task_data in yaml_data['modules'].items():
-            task_errors = validate_module(name, task_data, biolib_yaml_version)
-            if task_errors:
-                error_dict['modules'].update(task_errors)
-
-    # Just return empty dict if we have no errors
-    if error_dict['modules']:
-        return error_dict
-    else:
-        return {}
-
-
-def validate_yaml_config(yaml_data, source_files_zip_path):
-    source_files_zip = ZipFile(source_files_zip_path)
-    error_dict = {'config_yml': {}}
-
-    biolib_yaml_version = validate_and_get_biolib_yaml_version(yaml_data, error_dict)
-    error_dict['config_yml'].update(validate_app_version(yaml_data, biolib_yaml_version, source_files_zip))
-    error_dict['config_yml'].update(validate_modules(yaml_data, biolib_yaml_version))
-    error_dict['config_yml'].update(validate_arguments(yaml_data))
-
-    if error_dict['config_yml']:
-        print_errors(error_dict)
-        raise BiolibValidationError('Could not validate .biolib/config.yml')
-
-
-def print_errors(error_dict):
-    print(bl_colored("\nThe following validation errors were found in the .biolib/config.yml file:", 'red'))
-    print(yaml.safe_dump(error_dict, allow_unicode=True, default_flow_style=False))
-
-
-def write_output_files(mapped_output_files=None):
-    output_dir_path = 'biolib_results'
-
-    if os.path.exists(output_dir_path):
-        os.rename(output_dir_path, f'{output_dir_path}_old_{time.strftime("%Y%m%d%H%M%S")}')
-
-    if mapped_output_files:
-        logger.debug("Output Files:")
-
-        for path, data in mapped_output_files.items():
-            dirs, file = os.path.split(path)
-            path_on_disk = f'{output_dir_path}{path}'
-
-            if dirs:
-                os.makedirs(f'{output_dir_path}{dirs}', exist_ok=True)
-            if file:
-                open(path_on_disk, 'wb').write(data)
-
-            logger.debug(f"  - {path_on_disk}")
-
-        logger.debug('\n')
-
-
-def get_pretty_print_module_output_string(stdout=None, stderr=None, exitcode=None) -> str:
-    stderr_string = f"\n{bl_colored('stderr:', 'red')}\n{stderr.decode()}" if stderr else ''
-    return f'''{bl_colored('stdout:', 'green')}
-{stdout.decode()}{stderr_string}
-{bl_colored('exitcode:', 'green' if exitcode == 0 else 'red')} {exitcode}'''
-
-
-def _get_files_mappings(file_commands: List[str]) -> List[FilesMapping]:
-    files_mappings: List[FilesMapping] = []
-    for file_command in file_commands:
-        # TODO: figure out if splitting on space is good enough
-        _, from_path, to_path = file_command.split(' ')
-        files_mappings.append(FilesMapping(from_path=from_path, to_path=to_path))
-    return files_mappings
-
-
-def get_mocked_app_version_from_yaml(yaml_data: Dict, source_files_zip_path: str):
-    modules: List[Module] = []
-    for module_name in yaml_data['modules']:
-        yaml_module = yaml_data['modules'][module_name]
-
-        image_hostname, image_uri = yaml_module['image'].split('://')
-        if image_hostname != 'local-docker':
-            raise Exception(
-                f'Found image {image_uri} with hostname {image_hostname}, please use "local-docker://"'
-                f'Your application must use modules with local docker images to use run-dev'
-            )
-
-        modules.append(Module(
-            command=yaml_module.get('command', ''),
-            environment='biolib-ecr',
-            image_uri=image_uri,
-            input_files_mappings=_get_files_mappings(yaml_module['input_files']),
-            large_file_systems=[],
-            name=module_name,
-            output_files_mappings=_get_files_mappings(yaml_module['output_files']),
-            source_files_mappings=_get_files_mappings(yaml_module['source_files']),
-            working_directory=yaml_module['working_directory'],
-            estimated_image_size_bytes=None  # This should not be provided here
-        ))
-
-    return AppVersionOnJob(
-        client_side_executable_zip=source_files_zip_path,
-        consumes_stdin=True,
-        is_runnable_by_user=True,
-        modules=modules,
-        public_id='app-version-mock-id',
-        remote_hosts=[],
-        settings=[],
-        stdout_render_type='text',
-    )
-
-
-def create_temporary_directory_with_source_files_zip(app_path: str) -> Tuple[tempfile.TemporaryDirectory, str]:
-    original_working_directory = os.getcwd()
-    temporary_directory = tempfile.TemporaryDirectory()
-    os.chdir(app_path)
-    try:
-        zip_path_without_file_extension = os.path.join(temporary_directory.name, 'biolib-cli-tmp-source-files-zip')
-        zip_path = f'{zip_path_without_file_extension}.zip'
-        app_folder_name = Path(app_path).absolute().parts[-1]
-        shutil.make_archive(
-            base_name=zip_path_without_file_extension,
-            format='zip',
-            root_dir='..',
-            base_dir=app_folder_name,
-        )
-
-        return temporary_directory, zip_path
-
-    except Exception as error:
-        temporary_directory.cleanup()
-        raise Exception('Failed to create zip of application') from error
-
-    finally:
-        # change back to old working directory
-        os.chdir(original_working_directory)

biolib/compute_node/cloud_utils/enclave_parent_types.py

@@ -1,7 +0,0 @@
-from biolib.typing_utils import TypedDict
-
-
-class VsockProxyResponse(TypedDict):
-    hostname: str
-    id: str
-    port: int

biolib/compute_node/enclave/__init__.py

@@ -1,2 +0,0 @@
-# The CID for connections from the enclave to the parent
-PARENT_CID = 3

biolib/compute_node/enclave/enclave_remote_hosts.py

@@ -1,53 +0,0 @@
-from urllib.parse import urlparse
-from biolib.biolib_api_client import RemoteHost
-from biolib.biolib_docker_client import BiolibDockerClient
-from biolib.biolib_logging import logger
-from biolib.compute_node.remote_host_proxy import RemoteHostProxy
-from biolib.compute_node.webserver.webserver_types import WebserverConfig
-from biolib.typing_utils import List
-
-
-
-def start_enclave_remote_hosts(config: WebserverConfig) -> None:
-    logger.debug('Starting Docker network for enclave remote host proxies')
-    docker = BiolibDockerClient.get_docker_client()
-    public_network = docker.networks.create(
-        driver='bridge',
-        internal=False,
-        name='biolib-enclave-remote-hosts-network',
-    )
-
-    biolib_remote_hosts: List[RemoteHost] = []
-    biolib_remote_host_proxies: List[RemoteHostProxy] = []
-    base_hostname = urlparse(config['base_url']).hostname
-    # Make sure base_hostname is not None for typing reasons
-    if not base_hostname:
-        raise Exception('Base hostname not set, likely due to base url not being set. This is required in enclaves')
-
-    if base_hostname == 'biolib.com':
-        biolib_remote_hosts.append(RemoteHost(hostname='containers.biolib.com'))
-    elif base_hostname == 'staging-elb.biolib.com':
-        biolib_remote_hosts.append(RemoteHost(hostname='containers.staging.biolib.com'))
-
-    # Allow reaching backend for self registering and job creation
-    biolib_remote_hosts.append(RemoteHost(hostname=base_hostname))
-    # For downloading container image layers from S3 URLs returned by ECR proxy
-    biolib_remote_hosts.append(RemoteHost(
-        hostname=f"prod-{config['ecr_region_name']}-starport-layer-bucket.s3.{config['ecr_region_name']}.amazonaws.com"
-    ))
-    # For downloading source files zip
-    biolib_remote_hosts.append(RemoteHost(
-        hostname=f"{config['s3_general_storage_bucket_name']}.s3.amazonaws.com"
-    ))
-
-    logger.debug('Starting enclave remote host proxies')
-    for remote_host in biolib_remote_hosts:
-        remote_host_proxy = RemoteHostProxy(remote_host, public_network, internal_network=None, job_id=None)
-        remote_host_proxy.start()
-        biolib_remote_host_proxies.append(remote_host_proxy)
-
-    logger.debug('Writing to enclave /etc/hosts')
-    with open('/etc/hosts', mode='a') as hosts_file:
-        for proxy in biolib_remote_host_proxies:
-            ip_address = proxy.get_ip_address_on_network(public_network)
-            hosts_file.write(f'\n{ip_address} {proxy.hostname}')

biolib/compute_node/enclave/nitro_secure_module_utils.py

@@ -1,64 +0,0 @@
-"""
-This file is modified based on donkersgoed's repository (https://github.com/donkersgoed/nitropepper-enclave-app)
-"""
-
-import Crypto
-from Crypto.PublicKey import RSA
-from Crypto.Cipher import PKCS1_OAEP
-from Crypto.Hash import SHA256
-
-# enclave_build will only be present when running on an enclave
-import biolib.compute_node.enclave.libnsm as libnsm  # type: ignore # pylint: disable=import-error, no-name-in-module
-
-
-class NitroSecureModuleUtils:
-    """NSM util class."""
-
-    def __init__(self):
-        """Construct a new NSMUtil instance."""
-        # Initialize the Rust NSM Library
-        self._nsm_fd = libnsm.nsm_lib_init()  # pylint:disable=c-extension-no-member
-        # Create a new random function `nsm_rand_func`, which
-        # utilizes the NSM module.
-        self.nsm_rand_func = lambda num_bytes: libnsm.nsm_get_random(  # pylint:disable=c-extension-no-member
-            self._nsm_fd, num_bytes
-        )
-
-        # Force pycryptodome to use the new rand function.
-        # Without this, pycryptodome defaults to /dev/random
-        # and /dev/urandom, which are not available in Enclaves.
-        self._monkey_patch_crypto(self.nsm_rand_func)
-
-        # Generate a new RSA certificate, which will be used to
-        # generate the Attestation document and to decrypt results
-        # for KMS Decrypt calls with this document.
-        self._rsa_key = RSA.generate(2048)
-        self._public_key = self._rsa_key.publickey().export_key('DER')
-
-    def get_attestation_doc(self):
-        """Get the attestation document from /dev/nsm."""
-        libnsm_att_doc_cose_signed = libnsm.nsm_get_attestation_doc(  # pylint:disable=c-extension-no-member
-            self._nsm_fd,
-            self._public_key,
-            len(self._public_key)
-        )
-        return libnsm_att_doc_cose_signed
-
-    def decrypt(self, ciphertext):
-        """
-        Decrypt ciphertext using private key
-        """
-        cipher = PKCS1_OAEP.new(self._rsa_key, hashAlgo=SHA256)
-        plaintext = cipher.decrypt(ciphertext)
-
-        return plaintext
-
-    @classmethod
-    def _monkey_patch_crypto(cls, nsm_rand_func):
-        """Monkeypatch Crypto to use the NSM rand function."""
-        Crypto.Random.get_random_bytes = nsm_rand_func
-
-        def new_random_read(self, n_bytes):  # pylint:disable=unused-argument
-            return nsm_rand_func(n_bytes)
-
-        Crypto.Random._UrandomRNG.read = new_random_read  # pylint:disable=protected-access

biolib/compute_node/job_worker/executors/base_executor.py

@@ -1,18 +0,0 @@
-import abc
-
-from biolib.compute_node.job_worker.executors.types import LocalExecutorOptions
-
-
-class BaseExecutor(abc.ABC):
-
-    def __init__(self, options: LocalExecutorOptions):
-        self._options: LocalExecutorOptions = options
-        self._is_cleaning_up = False
-
-    @abc.abstractmethod
-    def execute_module(self, module_input_serialized: bytes) -> bytes:
-        pass
-
-    @abc.abstractmethod
-    def cleanup(self) -> None:
-        pass

biolib/compute_node/job_worker/executors/pyppeteer_executor.py

@@ -1,173 +0,0 @@
-import http.server
-import json
-import socketserver
-import threading
-import os
-import asyncio
-import subprocess
-import base64
-import sys
-import logging
-
-from biolib.typing_utils import Optional
-from biolib import utils
-from biolib.biolib_api_client import BiolibApiClient
-from biolib.biolib_errors import BioLibError
-from biolib.biolib_logging import logger, TRACE
-from biolib.compute_node.job_worker.executors.base_executor import BaseExecutor
-from biolib.compute_node.job_worker.executors.types import LocalExecutorOptions
-from biolib.pyppeteer.pyppeteer import launch, command  # type: ignore
-from biolib.pyppeteer.pyppeteer.launcher import resolveExecutablePath, __chromium_revision__  # type: ignore
-
-# specifically limit logs from pyppeteer
-logging.getLogger('biolib.pyppeteer.pyppeteer').setLevel(logging.ERROR)
-logging.getLogger('biolib.pyppeteer.pyppeteer.connection').setLevel(logging.ERROR)
-
-
-class RequestHandler(http.server.SimpleHTTPRequestHandler):
-    def log_message(self, format, *args):  # pylint: disable=redefined-builtin
-        if logger.level == TRACE:
-            http.server.SimpleHTTPRequestHandler.log_message(self, format, *args)
-
-
-class PyppeteerExecutor(BaseExecutor):
-    _chrome_executable_path: Optional[str] = None
-    _no_sandbox: bool = True
-
-    def execute_module(self, module_input_serialized: bytes) -> bytes:
-        with socketserver.TCPServer(('127.0.0.1', 0), RequestHandler) as httpd:
-            port = httpd.server_address[1]
-            thread = threading.Thread(target=httpd.serve_forever)
-            original_working_directory = os.getcwd()
-            # TODO: figure out how we can avoid changing the current directory
-            biolib_js_dir = os.path.join(utils.BIOLIB_PACKAGE_ROOT_DIR, 'biolib-js')
-            os.chdir(biolib_js_dir)
-            try:
-                thread.start()
-                module_output_serialized: bytes = asyncio.get_event_loop().run_until_complete(self._call_pyppeteer(
-                    port,
-                    self._options,
-                    module_input_serialized,
-                ))
-                return module_output_serialized
-            finally:
-                os.chdir(original_working_directory)
-                httpd.shutdown()
-                thread.join()
-
-    async def _call_pyppeteer(self, port: int, options: LocalExecutorOptions, module_input_serialized: bytes):
-        if not self._chrome_executable_path:
-            mac_chrome_path = '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome'
-            if os.path.isfile(mac_chrome_path):
-                self._chrome_executable_path = mac_chrome_path
-
-        if not self._chrome_executable_path:
-            linux_chrome_path = '/usr/lib/chromium-browser/chromium-browser'
-
-            # special install for google colab
-            if not os.path.isfile(linux_chrome_path) and 'google.colab' in sys.modules:
-                subprocess.run('apt-get update', shell=True, check=True)
-                subprocess.run('apt install chromium-chromedriver', shell=True, check=True)
-
-            if os.path.isfile(linux_chrome_path):
-                self._chrome_executable_path = linux_chrome_path
-
-        resolved_path = resolveExecutablePath(None, __chromium_revision__)
-        if not self._chrome_executable_path and resolved_path[1]:
-            # if executable_path is not set explicit,
-            # and resolveExecutablePath failed (== we got an error message back in resolved_path[1])
-            logger.info('Installing dependencies...')
-            os.environ['PYPPETEER_NO_PROGRESS_BAR'] = 'true'
-            command.install()
-
-        logger.info('Computing...')
-
-        chrome_arguments = [
-            '--disable-web-security',
-        ]
-        if self._no_sandbox:
-            chrome_arguments.append('--no-sandbox')
-
-        browser = await launch(args=chrome_arguments, executablePath=self._chrome_executable_path)
-
-        # start new page
-        page = await browser.newPage()
-
-        await page.goto('http://localhost:' + str(port))
-
-        def get_data():
-            return base64.b64encode(module_input_serialized).decode('ascii')
-
-        def set_progress_compute(value):
-            logger.debug(f'Compute progress: {value}')
-
-        def set_progress_initialization(value):
-            logger.debug(f'Initialization progress: {value}')
-
-        def add_log_message(value):
-            logger.debug(f'Log message: {value}')
-
-        await page.exposeFunction('getData', get_data)
-        await page.exposeFunction('setProgressCompute', set_progress_compute)
-        await page.exposeFunction('setProgressInitialization', set_progress_initialization)
-        await page.exposeFunction('addLogMessage', add_log_message)
-
-        api_client = BiolibApiClient.get()
-        refresh_token_js_value = 'undefined' if not api_client.refresh_token else f'"{api_client.refresh_token}"'
-
-        job = options['job'].copy()
-        if 'custom_compute_node_url' in job:
-            job.pop('custom_compute_node_url')
-
-        job_json_string = json.dumps(job)
-
-        output_serialized_js_bytes = await page.evaluate('''
-        async function() {
-          const refreshToken = ''' + refresh_token_js_value + ''';
-          const baseUrl = \'''' + options['biolib_base_url'] + '''\';
-          const job = ''' + job_json_string + ''';
-
-          const { BioLibSingleton, AppClient } = window.BioLib;
-          BioLibSingleton.setConfig({ baseUrl, refreshToken });
-          AppClient.setApiClient(BioLibSingleton.get());
-
-          const inputBase64 = await window.getData();
-          const inputByteArray = Uint8Array.from(atob(inputBase64), c => c.charCodeAt(0));
-
-          const jobUtils = {
-              setProgressCompute: window.setProgressCompute,
-              setProgressInitialization: window.setProgressInitialization,
-              addLogMessage: window.addLogMessage,
-          };
-
-          try {
-            const moduleOutput = await AppClient.runJob(job, inputByteArray, jobUtils);
-            return moduleOutput.serialize();
-          } catch(err) {
-            return err.toString();
-          }
-        }
-        ''')
-        logger.debug('Closing browser')
-        await browser.close()
-
-        module_output_serialized = self._js_to_python_byte_array_converter(output_serialized_js_bytes)
-
-        # TODO: check if module_output is correctly serialized
-        if isinstance(module_output_serialized, bytes):
-            return module_output_serialized
-        else:
-            raise BioLibError(module_output_serialized)
-
-    def cleanup(self):
-        pass
-
-    @staticmethod
-    def _js_to_python_byte_array_converter(js_encoded) -> bytes:
-        try:
-            return bytes(list([js_encoded[str(i)] for i in range(len(js_encoded))]))
-        except Exception as error:
-            logger.error('Failed to decode response from browser')
-            logger.error(error)
-            logger.error(js_encoded)
-            raise BioLibError(js_encoded) from error

biolib/compute_node/job_worker/executors/remote/__init__.py

@@ -1 +0,0 @@
-from biolib.compute_node.job_worker.executors.remote.remote_executor import RemoteExecutor

biolib/compute_node/job_worker/executors/remote/nitro_enclave_utils.py

@@ -1,81 +0,0 @@
-import cbor2  # type: ignore
-import cose  # type: ignore
-
-from cose import EC2, CoseAlgorithms, CoseEllipticCurves
-from Crypto.Util.number import long_to_bytes
-from OpenSSL import crypto
-
-from biolib import utils
-from biolib.biolib_errors import BioLibError
-
-
-class NitroEnclaveUtils:
-    def attest_enclave_and_get_rsa_public_key(self, expected_pcrs_and_aws_cert, attestation_document_bytes):
-        cbor_data = cbor2.loads(attestation_document_bytes)
-        cbor_document = cbor2.loads(cbor_data[2])
-        expected_pcrs_list = expected_pcrs_and_aws_cert['pcrObjectArray']
-        aws_nitro_root_cert_pem = "-----BEGIN CERTIFICATE-----\n" + \
-                                  expected_pcrs_and_aws_cert['awsNitroRootCertificateBase64'] + \
-                                  "\n-----END CERTIFICATE-----"
-        actual_pcrs = {str(k): v.hex() for k, v in cbor_document['pcrs'].items()}
-
-        if not utils.BIOLIB_CLOUD_SKIP_PCR_VERIFICATION:
-            self._assert_pcr_validity(actual_pcrs, expected_pcrs_list)
-
-        cert = crypto.load_certificate(crypto.FILETYPE_ASN1, cbor_document['certificate'])
-        self._assert_certificate_chain_validity(cbor_document['cabundle'], cert, aws_nitro_root_cert_pem)
-        self._assert_cose_signature_validity(cert, cbor_data)
-        return cbor_document['public_key']
-
-    def _assert_pcr_validity(self, actual_pcrs, expected_pcrs_list):
-        for expected_pcrs in expected_pcrs_list:
-            if self._does_pcr_object_match_actual(actual_pcrs, expected_pcrs):
-                return True
-
-        # Raise error if no match was fund
-        raise BioLibError('Failed to verify PCRs')
-
-    def _does_pcr_object_match_actual(self, actual_pcrs, expected_pcrs):
-        for pcr_key in expected_pcrs.keys():
-            if actual_pcrs[pcr_key] != expected_pcrs[pcr_key]:
-                return False
-            # If all matched return True
-            return True
-
-    def _assert_certificate_chain_validity(self, cabundle, cert, aws_nitro_root_cert_pem):
-        store = crypto.X509Store()
-        _cert = crypto.load_certificate(crypto.FILETYPE_PEM, aws_nitro_root_cert_pem)
-        store.add_cert(_cert)
-
-        for _cert_binary in cabundle[1:]:
-            _cert = crypto.load_certificate(crypto.FILETYPE_ASN1, _cert_binary)
-            store.add_cert(_cert)
-
-        store_ctx = crypto.X509StoreContext(store, cert)
-        try:
-            store_ctx.verify_certificate()
-        except Exception as exception:
-            raise BioLibError('Failed to verify certificates') from exception
-
-    def _assert_cose_signature_validity(self, cert, cbor_data):
-        phdr = cbor2.loads(cbor_data[0])
-        uhdr = cbor_data[1]
-        signature = cbor_data[3]
-
-        cert_public_numbers = cert.get_pubkey().to_cryptography_key().public_numbers()
-        x_long = cert_public_numbers.x
-        y_long = cert_public_numbers.y
-
-        x_bytes = long_to_bytes(x_long)
-        y_bytes = long_to_bytes(y_long)
-
-        # Create the EC2 key from public key parameters
-        key = EC2(alg=CoseAlgorithms.ES384, x=x_bytes, y=y_bytes, crv=CoseEllipticCurves.P_384)
-
-        # Construct the Sign1 message
-        msg = cose.Sign1Message(phdr=phdr, uhdr=uhdr, payload=cbor_data[2])
-        msg.signature = signature
-
-        # Verify the signature using the EC2 key
-        if not msg.verify_signature(key):
-            raise Exception('Failed to verify signature in attestation document')