coinex-api 0.0.7__py3-none-any.whl → 0.0.9__py3-none-any.whl

coinex_api/ccxt/static_dependencies/marshmallow_dataclass/collection_field.py

@@ -1,51 +0,0 @@
-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)

coinex_api/ccxt/static_dependencies/marshmallow_dataclass/lazy_class_attribute.py

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

coinex_api/ccxt/static_dependencies/marshmallow_dataclass/mypy.py

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

coinex_api/ccxt/static_dependencies/marshmallow_dataclass/typing.py

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

coinex_api/ccxt/static_dependencies/marshmallow_dataclass/union_field.py

@@ -1,82 +0,0 @@
-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)

coinex_api/ccxt/static_dependencies/marshmallow_oneofschema/__init__.py

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

coinex_api/ccxt/static_dependencies/marshmallow_oneofschema/one_of_schema.py

@@ -1,193 +0,0 @@
-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 {}

coinex_api/ccxt/static_dependencies/msgpack/__init__.py

@@ -1,55 +0,0 @@
-from .exceptions import *
-from .ext import ExtType, Timestamp
-
-import os
-
-
-version = (1, 0, 7)
-__version__ = "1.0.7"
-
-
-if os.environ.get("MSGPACK_PUREPYTHON"):
-    from .fallback import Packer, unpackb, Unpacker
-else:
-    try:
-        from ._cmsgpack import Packer, unpackb, Unpacker
-    except ImportError:
-        from .fallback import Packer, unpackb, Unpacker
-
-
-def pack(o, stream, **kwargs):
-    """
-    Pack object `o` and write it to `stream`
-
-    See :class:`Packer` for options.
-    """
-    packer = Packer(**kwargs)
-    stream.write(packer.pack(o))
-
-
-def packb(o, **kwargs):
-    """
-    Pack object `o` and return packed bytes
-
-    See :class:`Packer` for options.
-    """
-    return Packer(**kwargs).pack(o)
-
-
-def unpack(stream, **kwargs):
-    """
-    Unpack an object from `stream`.
-
-    Raises `ExtraData` when `stream` contains extra bytes.
-    See :class:`Unpacker` for options.
-    """
-    data = stream.read()
-    return unpackb(data, **kwargs)
-
-
-# alias for compatibility to simplejson/marshal/pickle.
-load = unpack
-loads = unpackb
-
-dump = pack
-dumps = packb

coinex_api/ccxt/static_dependencies/msgpack/_cmsgpack.pyx

@@ -1,11 +0,0 @@
-# coding: utf-8
-#cython: embedsignature=True, c_string_encoding=ascii, language_level=3
-from cpython.datetime cimport import_datetime, datetime_new
-import_datetime()
-
-import datetime
-cdef object utc = datetime.timezone.utc
-cdef object epoch = datetime_new(1970, 1, 1, 0, 0, 0, 0, tz=utc)
-
-include "_packer.pyx"
-include "_unpacker.pyx"