coinex-api 0.0.14__py3-none-any.whl → 0.0.15__py3-none-any.whl

coinex/ccxt/static_dependencies/marshmallow/base.py

@@ -1,65 +0,0 @@
-"""Abstract base classes.
-
-These are necessary to avoid circular imports between schema.py and fields.py.
-
-.. warning::
-
-    This module is treated as private API.
-    Users should not need to use this module directly.
-"""
-
-from __future__ import annotations
-
-from abc import ABC, abstractmethod
-
-
-class FieldABC(ABC):
-    """Abstract base class from which all Field classes inherit."""
-
-    parent = None
-    name = None
-    root = None
-
-    @abstractmethod
-    def serialize(self, attr, obj, accessor=None):
-        pass
-
-    @abstractmethod
-    def deserialize(self, value):
-        pass
-
-    @abstractmethod
-    def _serialize(self, value, attr, obj, **kwargs):
-        pass
-
-    @abstractmethod
-    def _deserialize(self, value, attr, data, **kwargs):
-        pass
-
-
-class SchemaABC(ABC):
-    """Abstract base class from which all Schemas inherit."""
-
-    @abstractmethod
-    def dump(self, obj, *, many: bool | None = None):
-        pass
-
-    @abstractmethod
-    def dumps(self, obj, *, many: bool | None = None):
-        pass
-
-    @abstractmethod
-    def load(self, data, *, many: bool | None = None, partial=None, unknown=None):
-        pass
-
-    @abstractmethod
-    def loads(
-        self,
-        json_data,
-        *,
-        many: bool | None = None,
-        partial=None,
-        unknown=None,
-        **kwargs,
-    ):
-        pass

coinex/ccxt/static_dependencies/marshmallow/class_registry.py

@@ -1,94 +0,0 @@
-"""A registry of :class:`Schema <marshmallow.Schema>` classes. This allows for string
-lookup of schemas, which may be used with
-class:`fields.Nested <marshmallow.fields.Nested>`.
-
-.. warning::
-
-    This module is treated as private API.
-    Users should not need to use this module directly.
-"""
-
-from __future__ import annotations
-
-import typing
-
-from .exceptions import RegistryError
-
-if typing.TYPE_CHECKING:
-    from . import Schema
-
-    SchemaType = typing.Type[Schema]
-
-# {
-#   <class_name>: <list of class objects>
-#   <module_path_to_class>: <list of class objects>
-# }
-_registry = {}  # type: dict[str, list[SchemaType]]
-
-
-def register(classname: str, cls: SchemaType) -> None:
-    """Add a class to the registry of serializer classes. When a class is
-    registered, an entry for both its classname and its full, module-qualified
-    path are added to the registry.
-
-    Example: ::
-
-        class MyClass:
-            pass
-
-
-        register("MyClass", MyClass)
-        # Registry:
-        # {
-        #   'MyClass': [path.to.MyClass],
-        #   'path.to.MyClass': [path.to.MyClass],
-        # }
-
-    """
-    # Module where the class is located
-    module = cls.__module__
-    # Full module path to the class
-    # e.g. user.schemas.UserSchema
-    fullpath = ".".join([module, classname])
-    # If the class is already registered; need to check if the entries are
-    # in the same module as cls to avoid having multiple instances of the same
-    # class in the registry
-    if classname in _registry and not any(
-        each.__module__ == module for each in _registry[classname]
-    ):
-        _registry[classname].append(cls)
-    elif classname not in _registry:
-        _registry[classname] = [cls]
-
-    # Also register the full path
-    if fullpath not in _registry:
-        _registry.setdefault(fullpath, []).append(cls)
-    else:
-        # If fullpath does exist, replace existing entry
-        _registry[fullpath] = [cls]
-    return None
-
-
-def get_class(classname: str, all: bool = False) -> list[SchemaType] | SchemaType:
-    """Retrieve a class from the registry.
-
-    :raises: marshmallow.exceptions.RegistryError if the class cannot be found
-        or if there are multiple entries for the given class name.
-    """
-    try:
-        classes = _registry[classname]
-    except KeyError as error:
-        raise RegistryError(
-            f"Class with name {classname!r} was not found. You may need "
-            "to import the class."
-        ) from error
-    if len(classes) > 1:
-        if all:
-            return _registry[classname]
-        raise RegistryError(
-            f"Multiple classes with name {classname!r} "
-            "were found. Please use the full, "
-            "module-qualified path."
-        )
-    else:
-        return _registry[classname][0]

coinex/ccxt/static_dependencies/marshmallow/decorators.py

@@ -1,231 +0,0 @@
-"""Decorators for registering schema pre-processing and post-processing methods.
-These should be imported from the top-level `marshmallow` module.
-
-Methods decorated with
-`pre_load <marshmallow.decorators.pre_load>`, `post_load <marshmallow.decorators.post_load>`,
-`pre_dump <marshmallow.decorators.pre_dump>`, `post_dump <marshmallow.decorators.post_dump>`,
-and `validates_schema <marshmallow.decorators.validates_schema>` receive
-``many`` as a keyword argument. In addition, `pre_load <marshmallow.decorators.pre_load>`,
-`post_load <marshmallow.decorators.post_load>`,
-and `validates_schema <marshmallow.decorators.validates_schema>` receive
-``partial``. If you don't need these arguments, add ``**kwargs`` to your method
-signature.
-
-
-Example: ::
-
-    from . import (
-        Schema,
-        pre_load,
-        pre_dump,
-        post_load,
-        validates_schema,
-        validates,
-        fields,
-        ValidationError,
-    )
-
-
-    class UserSchema(Schema):
-        email = fields.Str(required=True)
-        age = fields.Integer(required=True)
-
-        @post_load
-        def lowerstrip_email(self, item, many, **kwargs):
-            item["email"] = item["email"].lower().strip()
-            return item
-
-        @pre_load(pass_many=True)
-        def remove_envelope(self, data, many, **kwargs):
-            namespace = "results" if many else "result"
-            return data[namespace]
-
-        @post_dump(pass_many=True)
-        def add_envelope(self, data, many, **kwargs):
-            namespace = "results" if many else "result"
-            return {namespace: data}
-
-        @validates_schema
-        def validate_email(self, data, **kwargs):
-            if len(data["email"]) < 3:
-                raise ValidationError("Email must be more than 3 characters", "email")
-
-        @validates("age")
-        def validate_age(self, data, **kwargs):
-            if data < 14:
-                raise ValidationError("Too young!")
-
-.. note::
-    These decorators only work with instance methods. Class and static
-    methods are not supported.
-
-.. warning::
-    The invocation order of decorated methods of the same type is not guaranteed.
-    If you need to guarantee order of different processing steps, you should put
-    them in the same processing method.
-"""
-
-from __future__ import annotations
-
-import functools
-from typing import Any, Callable, cast
-
-PRE_DUMP = "pre_dump"
-POST_DUMP = "post_dump"
-PRE_LOAD = "pre_load"
-POST_LOAD = "post_load"
-VALIDATES = "validates"
-VALIDATES_SCHEMA = "validates_schema"
-
-
-class MarshmallowHook:
-    __marshmallow_hook__: dict[tuple[str, bool] | str, Any] | None = None
-
-
-def validates(field_name: str) -> Callable[..., Any]:
-    """Register a field validator.
-
-    :param str field_name: Name of the field that the method validates.
-    """
-    return set_hook(None, VALIDATES, field_name=field_name)
-
-
-def validates_schema(
-    fn: Callable[..., Any] | None = None,
-    pass_many: bool = False,
-    pass_original: bool = False,
-    skip_on_field_errors: bool = True,
-) -> Callable[..., Any]:
-    """Register a schema-level validator.
-
-    By default it receives a single object at a time, transparently handling the ``many``
-    argument passed to the `Schema`'s :func:`~marshmallow.Schema.validate` call.
-    If ``pass_many=True``, the raw data (which may be a collection) is passed.
-
-    If ``pass_original=True``, the original data (before unmarshalling) will be passed as
-    an additional argument to the method.
-
-    If ``skip_on_field_errors=True``, this validation method will be skipped whenever
-    validation errors have been detected when validating fields.
-
-    .. versionchanged:: 3.0.0b1
-        ``skip_on_field_errors`` defaults to `True`.
-
-    .. versionchanged:: 3.0.0
-        ``partial`` and ``many`` are always passed as keyword arguments to
-        the decorated method.
-    """
-    return set_hook(
-        fn,
-        (VALIDATES_SCHEMA, pass_many),
-        pass_original=pass_original,
-        skip_on_field_errors=skip_on_field_errors,
-    )
-
-
-def pre_dump(
-    fn: Callable[..., Any] | None = None, pass_many: bool = False
-) -> Callable[..., Any]:
-    """Register a method to invoke before serializing an object. The method
-    receives the object to be serialized and returns the processed object.
-
-    By default it receives a single object at a time, transparently handling the ``many``
-    argument passed to the `Schema`'s :func:`~marshmallow.Schema.dump` call.
-    If ``pass_many=True``, the raw data (which may be a collection) is passed.
-
-    .. versionchanged:: 3.0.0
-        ``many`` is always passed as a keyword arguments to the decorated method.
-    """
-    return set_hook(fn, (PRE_DUMP, pass_many))
-
-
-def post_dump(
-    fn: Callable[..., Any] | None = None,
-    pass_many: bool = False,
-    pass_original: bool = False,
-) -> Callable[..., Any]:
-    """Register a method to invoke after serializing an object. The method
-    receives the serialized object and returns the processed object.
-
-    By default it receives a single object at a time, transparently handling the ``many``
-    argument passed to the `Schema`'s :func:`~marshmallow.Schema.dump` call.
-    If ``pass_many=True``, the raw data (which may be a collection) is passed.
-
-    If ``pass_original=True``, the original data (before serializing) will be passed as
-    an additional argument to the method.
-
-    .. versionchanged:: 3.0.0
-        ``many`` is always passed as a keyword arguments to the decorated method.
-    """
-    return set_hook(fn, (POST_DUMP, pass_many), pass_original=pass_original)
-
-
-def pre_load(
-    fn: Callable[..., Any] | None = None, pass_many: bool = False
-) -> Callable[..., Any]:
-    """Register a method to invoke before deserializing an object. The method
-    receives the data to be deserialized and returns the processed data.
-
-    By default it receives a single object at a time, transparently handling the ``many``
-    argument passed to the `Schema`'s :func:`~marshmallow.Schema.load` call.
-    If ``pass_many=True``, the raw data (which may be a collection) is passed.
-
-    .. versionchanged:: 3.0.0
-        ``partial`` and ``many`` are always passed as keyword arguments to
-        the decorated method.
-    """
-    return set_hook(fn, (PRE_LOAD, pass_many))
-
-
-def post_load(
-    fn: Callable[..., Any] | None = None,
-    pass_many: bool = False,
-    pass_original: bool = False,
-) -> Callable[..., Any]:
-    """Register a method to invoke after deserializing an object. The method
-    receives the deserialized data and returns the processed data.
-
-    By default it receives a single object at a time, transparently handling the ``many``
-    argument passed to the `Schema`'s :func:`~marshmallow.Schema.load` call.
-    If ``pass_many=True``, the raw data (which may be a collection) is passed.
-
-    If ``pass_original=True``, the original data (before deserializing) will be passed as
-    an additional argument to the method.
-
-    .. versionchanged:: 3.0.0
-        ``partial`` and ``many`` are always passed as keyword arguments to
-        the decorated method.
-    """
-    return set_hook(fn, (POST_LOAD, pass_many), pass_original=pass_original)
-
-
-def set_hook(
-    fn: Callable[..., Any] | None, key: tuple[str, bool] | str, **kwargs: Any
-) -> Callable[..., Any]:
-    """Mark decorated function as a hook to be picked up later.
-    You should not need to use this method directly.
-
-    .. note::
-        Currently only works with functions and instance methods. Class and
-        static methods are not supported.
-
-    :return: Decorated function if supplied, else this decorator with its args
-        bound.
-    """
-    # Allow using this as either a decorator or a decorator factory.
-    if fn is None:
-        return functools.partial(set_hook, key=key, **kwargs)
-
-    # Set a __marshmallow_hook__ attribute instead of wrapping in some class,
-    # because I still want this to end up as a normal (unbound) method.
-    function = cast(MarshmallowHook, fn)
-    try:
-        hook_config = function.__marshmallow_hook__
-    except AttributeError:
-        function.__marshmallow_hook__ = hook_config = {}
-    # Also save the kwargs for the tagged function on
-    # __marshmallow_hook__, keyed by (<tag>, <pass_many>)
-    if hook_config is not None:
-        hook_config[key] = kwargs
-
-    return fn

coinex/ccxt/static_dependencies/marshmallow/error_store.py

@@ -1,60 +0,0 @@
-"""Utilities for storing collections of error messages.
-
-.. warning::
-
-    This module is treated as private API.
-    Users should not need to use this module directly.
-"""
-
-from .exceptions import SCHEMA
-
-
-class ErrorStore:
-    def __init__(self):
-        #: Dictionary of errors stored during serialization
-        self.errors = {}
-
-    def store_error(self, messages, field_name=SCHEMA, index=None):
-        # field error  -> store/merge error messages under field name key
-        # schema error -> if string or list, store/merge under _schema key
-        #              -> if dict, store/merge with other top-level keys
-        if field_name != SCHEMA or not isinstance(messages, dict):
-            messages = {field_name: messages}
-        if index is not None:
-            messages = {index: messages}
-        self.errors = merge_errors(self.errors, messages)
-
-
-def merge_errors(errors1, errors2):
-    """Deeply merge two error messages.
-
-    The format of ``errors1`` and ``errors2`` matches the ``message``
-    parameter of :exc:`marshmallow.exceptions.ValidationError`.
-    """
-    if not errors1:
-        return errors2
-    if not errors2:
-        return errors1
-    if isinstance(errors1, list):
-        if isinstance(errors2, list):
-            return errors1 + errors2
-        if isinstance(errors2, dict):
-            return dict(errors2, **{SCHEMA: merge_errors(errors1, errors2.get(SCHEMA))})
-        return errors1 + [errors2]
-    if isinstance(errors1, dict):
-        if isinstance(errors2, list):
-            return dict(errors1, **{SCHEMA: merge_errors(errors1.get(SCHEMA), errors2)})
-        if isinstance(errors2, dict):
-            errors = dict(errors1)
-            for key, val in errors2.items():
-                if key in errors:
-                    errors[key] = merge_errors(errors[key], val)
-                else:
-                    errors[key] = val
-            return errors
-        return dict(errors1, **{SCHEMA: merge_errors(errors1.get(SCHEMA), errors2)})
-    if isinstance(errors2, list):
-        return [errors1] + errors2
-    if isinstance(errors2, dict):
-        return dict(errors2, **{SCHEMA: merge_errors(errors1, errors2.get(SCHEMA))})
-    return [errors1, errors2]

coinex/ccxt/static_dependencies/marshmallow/exceptions.py

@@ -1,71 +0,0 @@
-"""Exception classes for marshmallow-related errors."""
-
-from __future__ import annotations
-
-import typing
-
-# Key used for schema-level validation errors
-SCHEMA = "_schema"
-
-
-class MarshmallowError(Exception):
-    """Base class for all marshmallow-related errors."""
-
-
-class ValidationError(MarshmallowError):
-    """Raised when validation fails on a field or schema.
-
-    Validators and custom fields should raise this exception.
-
-    :param message: An error message, list of error messages, or dict of
-        error messages. If a dict, the keys are subitems and the values are error messages.
-    :param field_name: Field name to store the error on.
-        If `None`, the error is stored as schema-level error.
-    :param data: Raw input data.
-    :param valid_data: Valid (de)serialized data.
-    """
-
-    def __init__(
-        self,
-        message: str | list | dict,
-        field_name: str = SCHEMA,
-        data: typing.Mapping[str, typing.Any]
-        | typing.Iterable[typing.Mapping[str, typing.Any]]
-        | None = None,
-        valid_data: list[dict[str, typing.Any]] | dict[str, typing.Any] | None = None,
-        **kwargs,
-    ):
-        self.messages = [message] if isinstance(message, (str, bytes)) else message
-        self.field_name = field_name
-        self.data = data
-        self.valid_data = valid_data
-        self.kwargs = kwargs
-        super().__init__(message)
-
-    def normalized_messages(self):
-        if self.field_name == SCHEMA and isinstance(self.messages, dict):
-            return self.messages
-        return {self.field_name: self.messages}
-
-    @property
-    def messages_dict(self) -> dict[str, typing.Any]:
-        if not isinstance(self.messages, dict):
-            raise TypeError(
-                "cannot access 'messages_dict' when 'messages' is of type "
-                + type(self.messages).__name__
-            )
-        return self.messages
-
-
-class RegistryError(NameError):
-    """Raised when an invalid operation is performed on the serializer
-    class registry.
-    """
-
-
-class StringNotCollectionError(MarshmallowError, TypeError):
-    """Raised when a string is passed when a list of strings is expected."""
-
-
-class FieldInstanceResolutionError(MarshmallowError, TypeError):
-    """Raised when schema to instantiate is neither a Schema class nor an instance."""