ccxt 4.2.77__py2.py3-none-any.whl → 4.4.49__py2.py3-none-any.whl

ccxt/static_dependencies/marshmallow/base.py

@@ -0,0 +1,65 @@
+"""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

ccxt/static_dependencies/marshmallow/class_registry.py

@@ -0,0 +1,94 @@
+"""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]

ccxt/static_dependencies/marshmallow/decorators.py

@@ -0,0 +1,231 @@
+"""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

ccxt/static_dependencies/marshmallow/error_store.py

@@ -0,0 +1,60 @@
+"""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]

ccxt/static_dependencies/marshmallow/exceptions.py

@@ -0,0 +1,71 @@
+"""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."""