pincer.utils.api_object

Complexity

Total Complexity

18

Size/Duplication

Total Lines	122
Duplicated Lines	0 %

Importance

Changes

0

# Copyright Pincer 2021-Present
# Full MIT License can be found in `LICENSE` at the project root.

from __future__ import annotations

import copy
import logging
from dataclasses import dataclass, fields, _is_dataclass_instance
from enum import Enum, EnumMeta
from inspect import getfullargspec
from sys import modules
from typing import (
    Dict, Tuple, Union, Generic, TypeVar, Any, TYPE_CHECKING,
    List, get_type_hints, get_origin, get_args
)

from .conversion import convert
from .types import MissingType, Singleton, MISSING
from ..exceptions import InvalidAnnotation

if TYPE_CHECKING:
    from ..client import Client
    from ..core.http import HTTPClient

T = TypeVar("T")

_log = logging.getLogger(__package__)


def _asdict_ignore_none(obj: Generic[T]) -> Union[Tuple, Dict, T]:
    """
    Returns a dict from a dataclass that ignores
    all values that are None
    Modification of _asdict_inner from dataclasses

    :param obj:
        Dataclass obj
    """

    if _is_dataclass_instance(obj):
        result = []
        for f in fields(obj):
            value = _asdict_ignore_none(getattr(obj, f.name))

            if isinstance(value, Enum):
                result.append((f.name, value.value))
            # This if statement was added to the function
            elif not isinstance(value, MissingType):
                result.append((f.name, value))

        return dict(result)

    elif isinstance(obj, tuple) and hasattr(obj, '_fields'):
        return type(obj)(*[_asdict_ignore_none(v) for v in obj])

    elif isinstance(obj, (list, tuple)):
        return type(obj)(_asdict_ignore_none(v) for v in obj)

    elif isinstance(obj, dict):
        return type(obj)(
            (
                _asdict_ignore_none(k),
                _asdict_ignore_none(v)
            ) for k, v in obj.items()
        )
    else:
        return copy.deepcopy(obj)


class HTTPMeta(type):
    __meta_items: List[str] = ["_client", "_http"]
    __ori_annotations: Dict[str, type] = {}

    def __new__(mcs, name, base, mapping):
        for key in HTTPMeta.__meta_items:
            if mapping.get("__annotations__") and \
                    (value := mapping["__annotations__"].get(key)):

invalid syntax (<unknown>, line 77)

                HTTPMeta.__ori_annotations.update({key: value})
                del mapping["__annotations__"][key]

        http_object = super().__new__(mcs, name, base, mapping)

        if getattr(http_object, "__annotations__", None):
            for k, v in HTTPMeta.__ori_annotations.items():
                http_object.__annotations__[k] = v
                setattr(http_object, k, None)

        return http_object


class TypeCache(metaclass=Singleton):
    cache = {}

    def __init__(self):
        lcp = modules.copy()
        for module in lcp:
            if not module.startswith("pincer"):
                continue

            TypeCache.cache.update(lcp[module].__dict__)


@dataclass
class APIObject(metaclass=HTTPMeta):
    """
    Represents an object which has been fetched from the Discord API.
    """
    _client: Client
    _http: HTTPClient

    def __get_types(self, attr: str, arg_type: type) -> Tuple[Any]:
        origin = get_origin(arg_type)

        if origin is Union:
            args = get_args(arg_type)

            if 2 <= len(args) < 4:
                return args

            raise InvalidAnnotation(
                f"Attribute `{attr}` in `{type(self).__name__}` has too many "
                f"or not enough arguments! (got {len(args)} expected 2-3)"