File Manager

X7ROOT File Manager

Current Path: /opt/alt/python311/lib/python3.11/site-packages/botocore

opt / alt / python311 / lib / python3.11 / site-packages / botocore /

📁 ..
📄 __init__.py(4.8 KB)
📁 __pycache__
📄 args.py(29.92 KB)
📄 auth.py(42.78 KB)
📄 awsrequest.py(22.61 KB)
📄 cacert.pem(260.37 KB)
📄 client.py(50.54 KB)
📄 compat.py(10.83 KB)
📄 compress.py(4.33 KB)
📄 config.py(15.24 KB)
📄 configloader.py(9.8 KB)
📄 configprovider.py(36.36 KB)
📄 credentials.py(82.81 KB)
📁 crt
📁 data
📄 discovery.py(10.82 KB)
📁 docs
📄 endpoint.py(16.06 KB)
📄 endpoint_provider.py(22.4 KB)
📄 errorfactory.py(3.63 KB)
📄 eventstream.py(19.97 KB)
📄 exceptions.py(22.27 KB)
📄 handlers.py(53.99 KB)
📄 history.py(1.7 KB)
📄 hooks.py(24.47 KB)
📄 httpchecksum.py(15.91 KB)
📄 httpsession.py(18.15 KB)
📄 loaders.py(18.39 KB)
📄 model.py(29.9 KB)
📄 monitoring.py(20.11 KB)
📄 paginate.py(26.75 KB)
📄 parsers.py(44.54 KB)
📄 regions.py(31.67 KB)
📄 response.py(7.06 KB)
📁 retries
📄 retryhandler.py(14.36 KB)
📄 serialize.py(32.35 KB)
📄 session.py(48.03 KB)
📄 signers.py(30.24 KB)
📄 stub.py(14.8 KB)
📄 tokens.py(10.65 KB)
📄 translate.py(3.33 KB)
📄 useragent.py(17.88 KB)
📄 utils.py(131.9 KB)
📄 validate.py(13.44 KB)
📁 vendored
📄 waiter.py(13.96 KB)

Editing: errorfactory.py

# Copyright 2016 Amazon.com, Inc. or its affiliates. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License"). You
# may not use this file except in compliance with the License. A copy of
# the License is located at
#
# http://aws.amazon.com/apache2.0/
#
# or in the "license" file accompanying this file. This file is
# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
# ANY KIND, either express or implied. See the License for the specific
# language governing permissions and limitations under the License.
from botocore.exceptions import ClientError
from botocore.utils import get_service_module_name

class BaseClientExceptions:
    ClientError = ClientError

def __init__(self, code_to_exception):
        """Base class for exceptions object on a client

:type code_to_exception: dict
        :param code_to_exception: Mapping of error codes (strings) to exception
            class that should be raised when encountering a particular
            error code.
        """
        self._code_to_exception = code_to_exception

def from_code(self, error_code):
        """Retrieves the error class based on the error code

This is helpful for identifying the exception class needing to be
        caught based on the ClientError.parsed_reponse['Error']['Code'] value

:type error_code: string
        :param error_code: The error code associated to a ClientError exception

:rtype: ClientError or a subclass of ClientError
        :returns: The appropriate modeled exception class for that error
            code. If the error code does not match any of the known
            modeled exceptions then return a generic ClientError.
        """
        return self._code_to_exception.get(error_code, self.ClientError)

def __getattr__(self, name):
        exception_cls_names = [
            exception_cls.__name__
            for exception_cls in self._code_to_exception.values()
        ]
        raise AttributeError(
            fr"{self} object has no attribute {name}. "
            fr"Valid exceptions are: {', '.join(exception_cls_names)}"
        )

class ClientExceptionsFactory:
    def __init__(self):
        self._client_exceptions_cache = {}

def create_client_exceptions(self, service_model):
        """Creates a ClientExceptions object for the particular service client

:type service_model: botocore.model.ServiceModel
        :param service_model: The service model for the client

:rtype: object that subclasses from BaseClientExceptions
        :returns: The exceptions object of a client that can be used
            to grab the various different modeled exceptions.
        """
        service_name = service_model.service_name
        if service_name not in self._client_exceptions_cache:
            client_exceptions = self._create_client_exceptions(service_model)
            self._client_exceptions_cache[service_name] = client_exceptions
        return self._client_exceptions_cache[service_name]

def _create_client_exceptions(self, service_model):
        cls_props = {}
        code_to_exception = {}
        for error_shape in service_model.error_shapes:
            exception_name = str(error_shape.name)
            exception_cls = type(exception_name, (ClientError,), {})
            cls_props[exception_name] = exception_cls
            code = str(error_shape.error_code)
            code_to_exception[code] = exception_cls
        cls_name = str(get_service_module_name(service_model) + 'Exceptions')
        client_exceptions_cls = type(
            cls_name, (BaseClientExceptions,), cls_props
        )
        return client_exceptions_cls(code_to_exception)

X7ROOT File Manager

Editing: errorfactory.py

Upload File

Create Folder