add tests | fix flake8 complaints

danielhasan1 · danielhasan1 · commit a243d2711327 · 2023-08-08T01:27:56.000+05:30
diff --git a/.flake8 b/.flake8
@@ -1,2 +1,2 @@
 [flake8]
-ignore = E501
+ignore = E501, F401
diff --git a/fastapi_listing/__init__.py b/fastapi_listing/__init__.py
@@ -1,10 +1,10 @@
 from fastapi_listing.factory import strategy_factory, interceptor_factory
 from fastapi_listing.strategies import QueryStrategy, PaginationStrategy, SortingOrderStrategy
-from fastapi_listing.service import ListingService, FastapiListing
+from fastapi_listing.service import ListingService, FastapiListing  # noqa: F401
 from fastapi_listing.interceptors import IterativeFilterInterceptor, IndiSorterInterceptor
 
 
-__version__ = "0.2.5"
+__version__ = "0.2.6"
 
 strategy_factory.register_strategy("default_paginator", PaginationStrategy)
 strategy_factory.register_strategy("default_sorter", SortingOrderStrategy)
diff --git a/fastapi_listing/abstracts/dao.py b/fastapi_listing/abstracts/dao.py
@@ -7,12 +7,12 @@ class DaoAbstract(metaclass=ABCMeta):
 
     @property
     @abstractmethod
-    def model(self):
+    def model(self) -> SqlAlchemyModel:
         pass
 
     @property
     @abstractmethod
-    def name(self):
+    def name(self) -> str:
         pass
 
     @abstractmethod
diff --git a/fastapi_listing/abstracts/listing.py b/fastapi_listing/abstracts/listing.py
@@ -1,9 +1,6 @@
 from sqlalchemy.orm import Query
 from abc import ABC, abstractmethod
-from typing import Type
 
-from fastapi_listing.abstracts import AbsSortingStrategy, \
-    AbsPaginatingStrategy
 from fastapi_listing.ctyping import ListingResponseType
 from fastapi_listing.interface.listing_meta_info import ListingMetaInfo
 from fastapi_listing.interface.client_site_params_adapter import ClientSiteParamAdapter
@@ -109,7 +106,5 @@ def _allowed_strategy_types(key: str) -> bool:
 
     def switch(self, strategy_type: str, strategy_name: str):
         if not self._allowed_strategy_types(strategy_type):
-            raise ValueError(f"unknown strategy type!")
+            raise ValueError("unknown strategy type!")
         setattr(self, strategy_type, strategy_name)
-
-
diff --git a/fastapi_listing/ctyping.py b/fastapi_listing/ctyping.py
@@ -30,5 +30,3 @@ class ListingResponseType(TypedDict):
 FastapiRequest = TypeVar("FastapiRequest", bound=Request)
 AnySqlAlchemyColumn = TypeVar("AnySqlAlchemyColumn", bound=Column)
 SqlAlchemyModel = TypeVar("SqlAlchemyModel", bound=DeclarativeMeta)
-
-
diff --git a/fastapi_listing/dao/dao_registry.py b/fastapi_listing/dao/dao_registry.py
@@ -7,7 +7,7 @@ def __init__(self):
 
     def register_dao(self, key: str, builder):
         if key is None or not key or type(key) is not str:
-            raise ValueError(f"Invalid type key, expected str type got {type(key)} for {builder.__name__}!")
+            raise ValueError(f"Invalid type key, expected str type got {type(key)} for {builder}!")
         if key in self._dao:
             raise ValueError(f"Dao name {key} already in use with {self._dao[key].__name__}!")
         self._dao[key] = builder
@@ -26,7 +26,7 @@ def create(self, key, *, replica=True, master=False, both=False):
         elif replica:
             dao_obj = dao_(read_db=SessionProvider.read_session)
         else:
-            raise ValueError
+            raise ValueError("Invalid creation type for dao object allowed types 'replica', 'master', or 'both'")
 
         return dao_obj
 
diff --git a/fastapi_listing/dao/generic_dao.py b/fastapi_listing/dao/generic_dao.py
@@ -5,7 +5,7 @@
 from fastapi_listing.ctyping import SqlAlchemyModel
 
 
-class GenericDao(DaoAbstract):  # type:ignore # noqa
+class GenericDao(DaoAbstract):
     """
     Dao stands for data access object.
     This layers encapsulates all logic that a user may write
@@ -39,7 +39,7 @@ def __init__(self, read_db=None, write_db=None):
         # we must have two sessions one for read replica and one for master or write replica
         # we should define our reusable attributes here that we will use in each dao method definition
         # even if we are using single db still having two references for the same session won't hurt
-        # for future expansion once we decide to move on to read/write replica architecure
+        # for future expansion once we decide to move on to read/write replica architecture
         # we already have groundwork done and only need to push different connections
         # from request lifecycle layer.
         self._read_db: Session = read_db  # kwargs.get("read_db")
diff --git a/fastapi_listing/errors.py b/fastapi_listing/errors.py
@@ -32,7 +32,7 @@ def __init__(self):
         msg = """
         No session found! Either you are not currently in a request context,
         or you need to manually create a session context and pass the callable to middleware args
-        e.g. 
+        e.g.
         callable -> get_db
         app.add_middleware(DaoSessionBinderMiddleware, master=get_db, replica=get_db)
         """
diff --git a/fastapi_listing/factory/_generic_factory.py b/fastapi_listing/factory/_generic_factory.py
@@ -15,13 +15,13 @@ def register(key: str, creator: Callable[..., Any]) -> None:
 
 def is_mapper_semantic_valid(mapper_val):
     if type(mapper_val) is not tuple:
-        raise ValueError(f"Invalid filter mapper semantic! Expected tuple!")
-    if len(mapper_val) < 2 or len(mapper_val) > 2:
-        raise ValueError(f"Invalid filter mapper semantic {mapper_val}! min tuple length should be 2.")
+        raise ValueError("Invalid sorter mapper semantic! Expected tuple!")
+    if len(mapper_val) != 2:
+        raise ValueError(f"Invalid sorter mapper semantic {mapper_val}! min tuple length should be 2.")
     if type(mapper_val[0]) is not str:
-        ValueError(f"Invalid filter mapper semantic {mapper_val}! first tuple element should be field (str)")
-    if len(mapper_val) == 3 and not isinstance(mapper_val[1], types.FunctionType):
-        raise ValueError(f"positional arg error, expects a callable but received: {mapper_val[2]}!")
+        raise ValueError(f"Invalid sorter mapper semantic {mapper_val}! first tuple element should be field (str)")
+    if not isinstance(mapper_val[1], types.FunctionType):
+        raise ValueError(f"positional arg error, expects a callable but received: {mapper_val[1]}!")
     return True
 
 
diff --git a/fastapi_listing/factory/filter.py b/fastapi_listing/factory/filter.py
@@ -13,29 +13,30 @@ def __init__(self):
     def register_filter(self, key: str, builder: CommonFilterImpl,
                         field_extractor_fn: Callable[[str], AnySqlAlchemyColumn] = None):
         if key is None or not key:
-            raise ValueError(f"Invalid type key!")
+            raise ValueError("Invalid type key!")
         if key in self._filters:
             raise ValueError(f"filter name already in use with {self._filters[key][0].__name__}!")
         self._filters[key] = (builder, field_extractor_fn)
 
     def is_mapper_semantic_valid(self, mapper_val):
         if type(mapper_val) is not tuple:
-            raise ValueError(f"Invalid filter mapper semantic! Expected tuple!")
+            raise ValueError("Invalid filter mapper semantic! Expected tuple!")
         if len(mapper_val) < 2 or len(mapper_val) > 3:
             raise ValueError(f"Invalid filter mapper semantic {mapper_val}! min tuple length should be 2.")
         if type(mapper_val[0]) is not str:
-            ValueError(f"Invalid filter mapper semantic {mapper_val}! first tuple element should be field (str)")
+            raise ValueError(f"Invalid filter mapper semantic {mapper_val}! first tuple element should be field (str)")
         if not inspect.isclass(mapper_val[1]):
-            raise ValueError(f"Invalid filter mapper semantic {mapper_val[1]}! Expects a class!")
-        if not issubclass(mapper_val[1], CommonFilterImpl):
-            raise ValueError(f"Invalid filter mapper semantic {mapper_val[1]}!"
+            raise ValueError(f"Invalid filter mapper semantic {mapper_val[1]!r}! Expects a class!")
+        if not issubclass(mapper_val[1], CommonFilterImpl) and mapper_val[1] != CommonFilterImpl:
+            raise ValueError(f"Invalid filter mapper semantic {mapper_val[1]!r}!"
                              f" Expects a subclass of CommonFilterImpl")
         if len(mapper_val) == 3 and not isinstance(mapper_val[2], types.FunctionType):
-            raise ValueError(f"positional arg error, expects a callable but received: {mapper_val[2]}!")
+            raise ValueError(f"positional arg error, expects a callable but received: {mapper_val[2]!r}!")
         return True
 
-    def register_filter_mapper(self, filter_mapper: Dict[str, Tuple[str, CommonFilterImpl,
-                                                              Optional[Callable[[str], AnySqlAlchemyColumn]]]]):
+    def register_filter_mapper(
+            self, filter_mapper: Dict[str, Tuple[str, CommonFilterImpl, Optional[Callable[[str], AnySqlAlchemyColumn]]]]
+    ):
         for key, val in filter_mapper.items():
             if self.is_mapper_semantic_valid(val):
                 self.register_filter(val[0], *val[1:])
@@ -44,7 +45,7 @@ def create(self, key: str, **kwargs):
         try:
             filter_, field_extractor_fn = self._filters[key]
         except KeyError:
-            raise ValueError(f"filter factory couldn't find registered key: {key}")
+            raise ValueError(f"filter factory couldn't find registered key {key!r}")
         return filter_(**kwargs, field_extract_fn=field_extractor_fn)
 
 
diff --git a/fastapi_listing/factory/interceptor.py b/fastapi_listing/factory/interceptor.py
@@ -1,4 +1,5 @@
 import inspect
+from fastapi_listing.abstracts import AbstractFilterInterceptor, AbstractSorterInterceptor
 
 
 class InterceptorObjectFactory:
@@ -7,18 +8,29 @@ def __init__(self):
 
     def register_interceptor(self, key: str, builder: type):
         if key is None or not key or type(key) is not str:
-            raise ValueError(f"Invalid type key!")
+            raise ValueError("Invalid type key!")
         if key in self._interceptor:
-            raise ValueError(f"interceptor name: {key}, already in use with {self._interceptor[key].__name__}!")
+            raise ValueError(f"interceptor name {key!r}, already in use with {self._interceptor[key].__name__!r}!")
         if not inspect.isclass(builder):
-            raise ValueError(f"builder is not a valid class!")
+            raise ValueError(f"{builder!r} is not a valid class!")
+        if issubclass(builder, AbstractSorterInterceptor) and not builder == AbstractSorterInterceptor:
+            pass
+        elif issubclass(builder, AbstractFilterInterceptor) and not builder == AbstractFilterInterceptor:
+            pass
+        else:
+            raise ValueError("Invalid interceptor class, expects a subclass of either "
+                             "'AbstractSorterInterceptor' or 'AbstractFilterInterceptor'")
+        # if (not issubclass(builder, AbstractFilterInterceptor) or not issubclass(builder, AbstractSorterInterceptor)
+        #         or builder == AbstractSorterInterceptor or builder == AbstractFilterInterceptor):
+        #     raise ValueError("Invalid interceptor class, expects a subclass of either "
+        #                      "'AbstractSorterInterceptor' or 'AbstractFilterInterceptor'")
         self._interceptor[key] = builder
 
     def create(self, key: str, *args, **kwargs) -> object:
-        strategy_ = self._interceptor.get(key)
-        if not strategy_:
-            raise ValueError(key)
-        return strategy_(*args, **kwargs)
+        interceptor_ = self._interceptor.get(key)
+        if not interceptor_:
+            raise ValueError(f"interceptor factory couldn't find register key {key!r}")
+        return interceptor_(*args, **kwargs)
 
     def aware_of(self, key: str) -> bool:
         return key in self._interceptor
diff --git a/fastapi_listing/factory/strategy.py b/fastapi_listing/factory/strategy.py
@@ -6,11 +6,11 @@ def __init__(self):
 
     def register_strategy(self, key: str, builder: type):
         if key is None or not key:
-            raise ValueError(f"Invalid type key!")
+            raise ValueError("Invalid type key!")
         if key in self._strategy:
             raise ValueError(f"strategy name: {key}, already in use with {self._strategy[key].__name__}!")
         if not isinstance(builder, object):
-            raise ValueError(f"builder is not a valid callable!")
+            raise ValueError("builder is not a valid callable!")
         self._strategy[key] = builder
 
     def create(self, key: str, *args, **kwargs) -> object:
diff --git a/fastapi_listing/interceptors/individual_sorter_interceptor.py b/fastapi_listing/interceptors/individual_sorter_interceptor.py
@@ -25,4 +25,3 @@ def apply(self, *, query: SqlAlchemyQuery = None, strategy: SortingOrderStrategy
         latest = sorting_params[-1]
         query = strategy.sort(query=query, value=latest, extra_context=extra_context)
         return query
-
diff --git a/fastapi_listing/loader.py b/fastapi_listing/loader.py
@@ -5,7 +5,7 @@
 from fastapi_listing.errors import MissingExpectedAttribute
 from fastapi_listing.dao import GenericDao
 
-import logging
+# import logging
 #
 # logger = logging.getLogger()
 # # fhandler = logging.FileHandler(filename=r"C:\Users\danis\dev\test.log", mode='a')
@@ -23,7 +23,7 @@
 
 def _validate_strategy_attributes(cls: ListingService):
     if not cls.default_srt_on:
-        raise MissingExpectedAttribute(f"default_srt_on attribute value is not provided! Did you forget to do it?")
+        raise MissingExpectedAttribute("default_srt_on attribute value is not provided! Did you forget to do it?")
     if not strategy_factory.aware_of(cls.query_strategy):
         missing_strategy = cls.query_strategy
     elif not strategy_factory.aware_of(cls.sorting_strategy):
@@ -40,19 +40,19 @@ def _validate_strategy_attributes(cls: ListingService):
 
 def _validate_dao_attribute(cls: ListingService):
     if cls.default_dao == GenericDao:
-        raise ValueError(f"Avoid using GenericDao Directly! Extend it!")
+        raise ValueError("Avoid using GenericDao Directly! Extend it!")
 
     if not inspect.isclass(cls.default_dao):
-        raise ValueError(f"Invalid Dao reference Injected!")
+        raise ValueError("Invalid Dao reference Injected!")
 
     if not issubclass(cls.default_dao, GenericDao):  # type: ignore
-        raise TypeError(f"Invalid Dao Type! Should Be type of GenericDao")
+        raise TypeError("Invalid Dao Type! Should Be type of GenericDao")
     return True
 
 
 def _validate_miscellaneous_attrs(cls: ListingService):
     if not cls.feature_params_adapter:
-        raise ValueError(f"Missing Adapter class for client param conversion!")
+        raise ValueError("Missing Adapter class for client param conversion!")
     temp = {type(cls.query_strategy), type(cls.sorting_strategy), type(cls.paginate_strategy), type(cls.sort_mecha),
             type(cls.filter_mecha), type(cls.default_srt_ord)}
     if {str} != temp:
@@ -61,7 +61,7 @@ def _validate_miscellaneous_attrs(cls: ListingService):
         raise ValueError(f"{cls.__name__} has invalid default_page_size attribute!")
 
     if not cls.default_srt_ord:
-        raise ValueError(f"Missing default_srt_ord attribute!")
+        raise ValueError("Missing default_srt_ord attribute!")
     missing_interceptor = ""
     if not interceptor_factory.aware_of(cls.filter_mecha):
         missing_interceptor = cls.filter_mecha
@@ -85,8 +85,3 @@ def _decorator(cls: ListingService):
                 _generic_factory.register_sort_mapper(val)
         return cls
     return _decorator
-
-
-
-
-
diff --git a/fastapi_listing/middlewares.py b/fastapi_listing/middlewares.py
@@ -1,7 +1,6 @@
-import contextlib
 from contextvars import ContextVar, Token
 from typing import Optional, Callable
-from contextlib import asynccontextmanager
+from contextlib import contextmanager
 
 from sqlalchemy.orm import Session
 from starlette.middleware.base import BaseHTTPMiddleware, RequestResponseEndpoint
@@ -19,7 +18,7 @@
 class DaoSessionBinderMiddleware(BaseHTTPMiddleware):
     def __init__(
             self,
-            app: ASGIApp,*,
+            app: ASGIApp, *,
             master: Callable[[], Session] = None,
             replica: Callable[[], Session] = None,
             session_close_implicit: bool = False
@@ -31,7 +30,7 @@ def __init__(
 
     async def dispatch(self, request: Request, call_next: RequestResponseEndpoint) -> Response:
         # TODO: lazy sessions
-        async with manager(self.read, self.master, self.close_implicit):
+        with manager(self.read, self.master, self.close_implicit):
             response = await call_next(request)
         return response
 
@@ -57,14 +56,13 @@ class SessionProvider(metaclass=SessionProviderMeta):
     pass
 
 
-@asynccontextmanager
-async def manager(read_ses: Callable, master: Callable, implicit_close):
+@contextmanager
+def manager(read_ses: Callable, master: Callable, implicit_close):
     global _session
     global _replica_session
-
     if read_ses and master:
-        token_read_session: Token = _session.set(read_ses())
-        token_master_session: Token = _replica_session.set(master())
+        token_read_session: Token = _replica_session.set(read_ses())
+        token_master_session: Token = _session.set(master())
     elif master:
         token_master_session: Token = _session.set(master())
     elif read_ses:
diff --git a/fastapi_listing/paginator/default_page_format.py b/fastapi_listing/paginator/default_page_format.py
@@ -1,7 +1,5 @@
 from typing import Sequence, TypeVar, Generic
 import warnings
-
-from pydantic.generics import GenericModel
 from fastapi_listing.utils import HAS_PYDANTIC, IS_PYDANTIC_V2
 
 
diff --git a/fastapi_listing/service/_core_listing_service.py b/fastapi_listing/service/_core_listing_service.py
@@ -7,7 +7,7 @@
 from fastapi_listing.dao.generic_dao import GenericDao
 from fastapi_listing.errors import FastapiListingRequestSemanticApiException, \
     NotRegisteredApiException
-from fastapi_listing.factory import strategy_factory, interceptor_factory
+from fastapi_listing.factory import interceptor_factory
 from fastapi_listing.interface.listing_meta_info import ListingMetaInfo
 from fastapi_listing.ctyping import ListingResponseType
 from fastapi_listing.utils import HAS_PYDANTIC, BaseModel
@@ -49,7 +49,7 @@ def _replace_aliases(mapper: Dict[str, str], req_params: List[Dict[str, str]]) -
             elif type(mapper[param["field"]]) is str:
                 param["field"] = mapper[param["field"]]
             else:
-                raise ValueError(f"invalid field mapper")
+                raise ValueError("invalid field mapper")
         return req_params
 
     def _apply_sorting(self, query: Query, listing_meta_info: ListingMetaInfo) -> Query:
@@ -82,7 +82,7 @@ def _apply_filters(self, query: Query, listing_meta_info: ListingMetaInfo) -> Qu
             fltrs: List[dict] = listing_meta_info.feature_params_adapter.get("filter")
         except Exception:
             raise FastapiListingRequestSemanticApiException(status_code=422,
-                                                            detail=f"Crap! Filtering went wrong.")
+                                                            detail="Crap! Filtering went wrong.")
         temp = set(item.get("field") for item in fltrs) - set(listing_meta_info.filter_column_mapper.keys())
         if temp:
             raise NotRegisteredApiException(
@@ -104,7 +104,7 @@ def _paginate(self, query: Query, listing_meta_info: ListingMetaInfo) -> Listing
             raw_params = listing_meta_info.feature_params_adapter.get("pagination")
             page_params = raw_params if raw_params else {"page": 1, "pageSize": listing_meta_info.default_page_size}
             paginator_params: dict = page_params
-        except Exception as e:
+        except Exception:
             raise FastapiListingRequestSemanticApiException(status_code=422,
                                                             detail="Crap! Pagination went wrong.")
         page = listing_meta_info.paginating_strategy.paginate(query,
diff --git a/fastapi_listing/service/listing_main.py b/fastapi_listing/service/listing_main.py
@@ -1,5 +1,3 @@
-from typing import NamedTuple, Callable, Optional
-
 from fastapi import Request
 
 from fastapi_listing.abstracts import ListingServiceBase
diff --git a/fastapi_listing/sorter/page_sorter.py b/fastapi_listing/sorter/page_sorter.py
@@ -1,4 +1,4 @@
-from typing import Dict, Callable
+from typing import Dict
 from fastapi_listing.abstracts import AbsSortingStrategy
 from fastapi_listing.ctyping import SqlAlchemyModel, FastapiRequest, SqlAlchemyQuery, AnySqlAlchemyColumn
 from fastapi_listing.factory import _generic_factory
diff --git a/fastapi_listing/strategies/__init__.py b/fastapi_listing/strategies/__init__.py
diff --git a/tests/dao_setup.py b/tests/dao_setup.py
diff --git a/tests/fake_listing_setup.py b/tests/fake_listing_setup.py
diff --git a/tests/service_setup.py b/tests/service_setup.py
diff --git a/tests/test_main.py b/tests/test_main.py
diff --git a/tests/test_main_v2.py b/tests/test_main_v2.py

Original file line number	Diff line number	Diff line change
`@@ -1,2 +1,2 @@`
`1`	`1`	`[flake8]`
`2`		`-ignore = E501`
	`2`	`+ignore = E501, F401`