fuck not having a type checker and fuck ORMs

typmappingcursor.py

# an idea

from sqlalchemy.engine import ResultProxy
from typing import TypeVar, List, Generic, Optional, Union

T = TypeVar('T')

class TypeMappingCursor(Generic[T]):
    @classmethod
    def from_auto(cls: type, mapping_function_or_type: Any, result_proxy: ResultProxy) -> cls:
        if attr.has(mapping_function_or_type):
            return cls.from_attrs(mapping_function_or_type, result)
        if inspect.isclass(mapping_function_or_type):
            return cls.from_class(mapping_function_or_type, )
        return cls(mapping_function_or_type, result)

    @classmethod
    def from_mapping_function(mapping_function: Any, result_proxy: ResultProxy) -> cls:
        return TypeMappingCursor(mapping_function, result_proxy)

    @classmethod
    def from_attrs(cls: type, attrs_class: type, result_proxy: ResultProxy) -> cls:
        assert attr.has(attrs_class)
        def mapping_function(rowproxy):
            raise NotImplementedError()

    def __init__(mapping_function: Any, result_proxy: ResultProxy):
        assert(callable(mapping_function))
        assert isinstance(result_proxy, ResultProxy)
        self.__mapping_function = mapping_function
        self.__result_proxy = result_proxy

    def close(self) -> None:
        self.__result_proxy.close()

    def fetchall(self) -> Optional[List[T]]:
        return list(map(self.__mapping_function, self.__result_proxy.fetchall()))

    def fetchmany(self, size: Optional[int]=None) -> Optional[List[T]]:
        return list(map(self.__mapping_function, self.__result_proxy.fetchmany(size)))

    def first(self) -> Optional[T]:
        return self.__mapping_function(self.__result_proxy.first())

    def keys(self) -> List[str]:
        return self.__result_proxy.keys()

    @property
    def rowcount(self) -> int:
        return self.__result_proxy.rowcount

    @property
    def returns_rows(self) - bool:
        return self.__result_proxy.returns_rows

    @property
    def closed(self) -> bool:
        return self.__result_proxy._soft_closed or self.__result_proxy.closed

    @property
    def result_proxy(self) -> sqlalchemy.engine.ResultProxy:
        return self.__result_proxy

    @property
    def mapping_function(self) -> Callable([sqlalchemy.RowProxy], T):
        return self.__mapping_function

    def __iter__(self) Iterator[T]:
        for row in self.__result_proxy:
            yield self.__mapping_function(row)