bitmart 0.0.116__py3-none-any.whl

bitmart/ccxt/static_dependencies/marshmallow_dataclass/collection_field.py

@@ -0,0 +1,51 @@
+import typing
+
+import marshmallow
+
+
+class Sequence(marshmallow.fields.List):
+    """
+    A sequence field, basically an immutable version of the list field.
+    """
+
+    def _deserialize(  # type: ignore[override]
+        self,
+        value: typing.Any,
+        attr: typing.Any,
+        data: typing.Any,
+        **kwargs: typing.Any,
+    ) -> typing.Optional[typing.Sequence[typing.Any]]:
+        optional_list = super()._deserialize(value, attr, data, **kwargs)
+        return None if optional_list is None else tuple(optional_list)
+
+
+class Set(marshmallow.fields.List):
+    """
+    A set field. A set is an unordered/mutable collection of unique elements, same for frozenset
+    except it's immutable.
+
+    Notes:
+        Beware the a Set guarantees uniqueness in the resulting list but in return the item's order
+        will be random. So if the order matters, use a List or Sequence !
+    """
+
+    def __init__(
+        self,
+        cls_or_instance: typing.Union[marshmallow.fields.Field, type],
+        frozen: bool = False,
+        **kwargs,
+    ):
+        super().__init__(cls_or_instance, **kwargs)
+        self.set_type: typing.Type[typing.Union[frozenset, set]] = (
+            frozenset if frozen else set
+        )
+
+    def _deserialize(  # type: ignore[override]
+        self,
+        value: typing.Any,
+        attr: typing.Any,
+        data: typing.Any,
+        **kwargs: typing.Any,
+    ) -> typing.Union[typing.Set[typing.Any], typing.FrozenSet[typing.Any], None]:
+        optional_list = super()._deserialize(value, attr, data, **kwargs)
+        return None if optional_list is None else self.set_type(optional_list)

bitmart/ccxt/static_dependencies/marshmallow_dataclass/lazy_class_attribute.py

@@ -0,0 +1,45 @@
+from typing import Any, Callable, Optional
+
+
+__all__ = ("lazy_class_attribute",)
+
+
+class LazyClassAttribute:
+    """Descriptor decorator implementing a class-level, read-only
+    property, which caches its results on the class(es) on which it
+    operates.
+    """
+
+    __slots__ = ("func", "name", "called", "forward_value")
+
+    def __init__(
+        self,
+        func: Callable[..., Any],
+        name: Optional[str] = None,
+        forward_value: Any = None,
+    ):
+        self.func = func
+        self.name = name
+        self.called = False
+        self.forward_value = forward_value
+
+    def __get__(self, instance, cls=None):
+        if not cls:
+            cls = type(instance)
+
+        # avoid recursion
+        if self.called:
+            return self.forward_value
+
+        self.called = True
+
+        setattr(cls, self.name, self.func())
+
+        # "getattr" is used to handle bounded methods
+        return getattr(cls, self.name)
+
+    def __set_name__(self, owner, name):
+        self.name = self.name or name
+
+
+lazy_class_attribute = LazyClassAttribute

bitmart/ccxt/static_dependencies/marshmallow_dataclass/mypy.py

@@ -0,0 +1,71 @@
+import inspect
+from typing import Callable, Optional, Type
+
+from mypy import nodes
+from mypy.plugin import DynamicClassDefContext, Plugin
+from mypy.plugins import dataclasses
+
+import marshmallow_dataclass
+
+_NEW_TYPE_SIG = inspect.signature(marshmallow_dataclass.NewType)
+
+
+def plugin(version: str) -> Type[Plugin]:
+    return MarshmallowDataclassPlugin
+
+
+class MarshmallowDataclassPlugin(Plugin):
+    def get_dynamic_class_hook(
+        self, fullname: str
+    ) -> Optional[Callable[[DynamicClassDefContext], None]]:
+        if fullname == "marshmallow_dataclass.NewType":
+            return new_type_hook
+        return None
+
+    def get_class_decorator_hook(self, fullname: str):
+        if fullname == "marshmallow_dataclass.dataclass":
+            return dataclasses.dataclass_class_maker_callback
+        return None
+
+
+def new_type_hook(ctx: DynamicClassDefContext) -> None:
+    """
+    Dynamic class hook for :func:`marshmallow_dataclass.NewType`.
+
+    Uses the type of the ``typ`` argument.
+    """
+    typ = _get_arg_by_name(ctx.call, "typ", _NEW_TYPE_SIG)
+    if not isinstance(typ, nodes.RefExpr):
+        return
+    info = typ.node
+    if not isinstance(info, nodes.TypeInfo):
+        return
+    ctx.api.add_symbol_table_node(ctx.name, nodes.SymbolTableNode(nodes.GDEF, info))
+
+
+def _get_arg_by_name(
+    call: nodes.CallExpr, name: str, sig: inspect.Signature
+) -> Optional[nodes.Expression]:
+    """
+    Get value of argument from a call.
+
+    :return: The argument value, or ``None`` if it cannot be found.
+
+    .. warning::
+        This probably doesn't yet work for calls with ``*args`` and/or ``*kwargs``.
+    """
+    args = []
+    kwargs = {}
+    for arg_name, arg_value in zip(call.arg_names, call.args):
+        if arg_name is None:
+            args.append(arg_value)
+        else:
+            kwargs[arg_name] = arg_value
+    try:
+        bound_args = sig.bind(*args, **kwargs)
+    except TypeError:
+        return None
+    try:
+        return bound_args.arguments[name]
+    except KeyError:
+        return None

bitmart/ccxt/static_dependencies/marshmallow_dataclass/typing.py

@@ -0,0 +1,14 @@
+import sys
+
+import marshmallow.fields
+
+if sys.version_info >= (3, 9):
+    from typing import Annotated
+else:
+    from typing_extensions import Annotated
+
+Url = Annotated[str, marshmallow.fields.Url]
+Email = Annotated[str, marshmallow.fields.Email]
+
+# Aliases
+URL = Url

bitmart/ccxt/static_dependencies/marshmallow_dataclass/union_field.py

@@ -0,0 +1,82 @@
+import copy
+import inspect
+from typing import List, Tuple, Any, Optional
+
+import typeguard
+from marshmallow import fields, Schema, ValidationError
+
+try:
+    from typeguard import TypeCheckError  # type: ignore[attr-defined]
+except ImportError:
+    # typeguard < 3
+    TypeCheckError = TypeError  # type: ignore[misc, assignment]
+
+if "argname" not in inspect.signature(typeguard.check_type).parameters:
+
+    def _check_type(value, expected_type, argname: str):
+        return typeguard.check_type(value=value, expected_type=expected_type)
+
+else:
+    # typeguard < 3.0.0rc2
+    def _check_type(value, expected_type, argname: str):
+        return typeguard.check_type(  # type: ignore[call-overload]
+            value=value, expected_type=expected_type, argname=argname
+        )
+
+
+class Union(fields.Field):
+    """A union field, composed other `Field` classes or instances.
+    This field serializes elements based on their type, with one of its child fields.
+
+    Example: ::
+
+        number_or_string = UnionField([
+                    (float, fields.Float()),
+                    (str, fields.Str())
+                ])
+
+    :param union_fields: A list of types and their associated field instance.
+    :param kwargs: The same keyword arguments that :class:`Field` receives.
+    """
+
+    def __init__(self, union_fields: List[Tuple[type, fields.Field]], **kwargs):
+        super().__init__(**kwargs)
+        self.union_fields = union_fields
+
+    def _bind_to_schema(self, field_name: str, schema: Schema) -> None:
+        super()._bind_to_schema(field_name, schema)
+        new_union_fields = []
+        for typ, field in self.union_fields:
+            field = copy.deepcopy(field)
+            field._bind_to_schema(field_name, self)
+            new_union_fields.append((typ, field))
+
+        self.union_fields = new_union_fields
+
+    def _serialize(self, value: Any, attr: Optional[str], obj, **kwargs) -> Any:
+        errors = []
+        if value is None:
+            return value
+        for typ, field in self.union_fields:
+            try:
+                _check_type(value=value, expected_type=typ, argname=attr or "anonymous")
+                return field._serialize(value, attr, obj, **kwargs)
+            except TypeCheckError as e:
+                errors.append(e)
+        raise TypeError(
+            f"Unable to serialize value with any of the fields in the union: {errors}"
+        )
+
+    def _deserialize(self, value: Any, attr: Optional[str], data, **kwargs) -> Any:
+        errors = []
+        for typ, field in self.union_fields:
+            try:
+                result = field.deserialize(value, **kwargs)
+                _check_type(
+                    value=result, expected_type=typ, argname=attr or "anonymous"
+                )
+                return result
+            except (TypeCheckError, ValidationError) as e:
+                errors.append(e)
+
+        raise ValidationError(errors)

bitmart/ccxt/static_dependencies/marshmallow_oneofschema/__init__.py

@@ -0,0 +1 @@
+from .one_of_schema import OneOfSchema  # noqa

bitmart/ccxt/static_dependencies/marshmallow_oneofschema/one_of_schema.py

@@ -0,0 +1,193 @@
+import typing
+
+from ..marshmallow import Schema, ValidationError
+
+
+class OneOfSchema(Schema):
+    """
+    This is a special kind of schema that actually multiplexes other schemas
+    based on object type. When serializing values, it uses get_obj_type() method
+    to get object type name. Then it uses `type_schemas` name-to-Schema mapping
+    to get schema for that particular object type, serializes object using that
+    schema and adds an extra "type" field with name of object type.
+    Deserialization is reverse.
+
+    Example:
+
+        class Foo(object):
+            def __init__(self, foo):
+                self.foo = foo
+
+        class Bar(object):
+            def __init__(self, bar):
+                self.bar = bar
+
+        class FooSchema(marshmallow.Schema):
+            foo = marshmallow.fields.String(required=True)
+
+            @marshmallow.post_load
+            def make_foo(self, data, **kwargs):
+                return Foo(**data)
+
+        class BarSchema(marshmallow.Schema):
+            bar = marshmallow.fields.Integer(required=True)
+
+            @marshmallow.post_load
+            def make_bar(self, data, **kwargs):
+                return Bar(**data)
+
+        class MyUberSchema(marshmallow.OneOfSchema):
+            type_schemas = {
+                'foo': FooSchema,
+                'bar': BarSchema,
+            }
+
+            def get_obj_type(self, obj):
+                if isinstance(obj, Foo):
+                    return 'foo'
+                elif isinstance(obj, Bar):
+                    return 'bar'
+                else:
+                    raise Exception('Unknown object type: %s' % repr(obj))
+
+        MyUberSchema().dump([Foo(foo='hello'), Bar(bar=123)], many=True)
+        # => [{'type': 'foo', 'foo': 'hello'}, {'type': 'bar', 'bar': 123}]
+
+    You can control type field name added to serialized object representation by
+    setting `type_field` class property.
+    """
+
+    type_field = "type"
+    type_field_remove = True
+    type_schemas: typing.Mapping[str, typing.Union[typing.Type[Schema], Schema]] = {}
+
+    def get_obj_type(self, obj):
+        """Returns name of the schema during dump() calls, given the object
+        being dumped."""
+        return obj.__class__.__name__
+
+    def get_data_type(self, data):
+        """Returns name of the schema during load() calls, given the data being
+        loaded. Defaults to looking up `type_field` in the data."""
+        data_type = data.get(self.type_field)
+        if self.type_field in data and self.type_field_remove:
+            data.pop(self.type_field)
+        return data_type
+
+    def dump(self, obj, *, many=None, **kwargs):
+        errors = {}
+        result_data = []
+        result_errors = {}
+        many = self.many if many is None else bool(many)
+        if not many:
+            result = result_data = self._dump(obj, **kwargs)
+        else:
+            for idx, o in enumerate(obj):
+                try:
+                    result = self._dump(o, **kwargs)
+                    result_data.append(result)
+                except ValidationError as error:
+                    result_errors[idx] = error.normalized_messages()
+                    result_data.append(error.valid_data)
+
+        result = result_data
+        errors = result_errors
+
+        if not errors:
+            return result
+        else:
+            exc = ValidationError(errors, data=obj, valid_data=result)
+            raise exc
+
+    def _dump(self, obj, *, update_fields=True, **kwargs):
+        obj_type = self.get_obj_type(obj)
+        if obj_type is None:
+            return (
+                None,
+                {"_schema": f"Unknown object class: {obj.__class__.__name__}"},
+            )
+
+        type_schema = self.type_schemas.get(obj_type)
+        if not type_schema:
+            return None, {"_schema": f"Unsupported object type: {obj_type}"}
+
+        schema = type_schema if isinstance(type_schema, Schema) else type_schema()
+
+        schema.context.update(getattr(self, "context", {}))
+
+        result = schema.dump(obj, many=False, **kwargs)
+        if result is not None:
+            result[self.type_field] = obj_type
+        return result
+
+    def load(self, data, *, many=None, partial=None, unknown=None, **kwargs):
+        errors = {}
+        result_data = []
+        result_errors = {}
+        many = self.many if many is None else bool(many)
+        if partial is None:
+            partial = self.partial
+        if not many:
+            try:
+                result = result_data = self._load(
+                    data, partial=partial, unknown=unknown, **kwargs
+                )
+                #  result_data.append(result)
+            except ValidationError as error:
+                result_errors = error.normalized_messages()
+                result_data.append(error.valid_data)
+        else:
+            for idx, item in enumerate(data):
+                try:
+                    result = self._load(item, partial=partial, **kwargs)
+                    result_data.append(result)
+                except ValidationError as error:
+                    result_errors[idx] = error.normalized_messages()
+                    result_data.append(error.valid_data)
+
+        result = result_data
+        errors = result_errors
+
+        if not errors:
+            return result
+        else:
+            exc = ValidationError(errors, data=data, valid_data=result)
+            raise exc
+
+    def _load(self, data, *, partial=None, unknown=None, **kwargs):
+        if not isinstance(data, dict):
+            raise ValidationError({"_schema": f"Invalid data type: {data}"})
+
+        data = dict(data)
+        unknown = unknown or self.unknown
+        data_type = self.get_data_type(data)
+
+        if data_type is None:
+            raise ValidationError(
+                {self.type_field: ["Missing data for required field."]}
+            )
+
+        try:
+            type_schema = self.type_schemas.get(data_type)
+        except TypeError as error:
+            # data_type could be unhashable
+            raise ValidationError(
+                {self.type_field: [f"Invalid value: {data_type}"]}
+            ) from error
+        if not type_schema:
+            raise ValidationError(
+                {self.type_field: [f"Unsupported value: {data_type}"]}
+            )
+
+        schema = type_schema if isinstance(type_schema, Schema) else type_schema()
+
+        schema.context.update(getattr(self, "context", {}))
+
+        return schema.load(data, many=False, partial=partial, unknown=unknown, **kwargs)
+
+    def validate(self, data, *, many=None, partial=None):
+        try:
+            self.load(data, many=many, partial=partial)
+        except ValidationError as ve:
+            return ve.messages
+        return {}

bitmart/ccxt/static_dependencies/mnemonic/__init__.py

@@ -0,0 +1,4 @@
+# https://github.com/trezor/python-mnemonic/tree/v0.21
+from .mnemonic import Mnemonic
+
+__all__ = ["Mnemonic"]