fastapi-startkit 0.1.0__py3-none-any.whl

fastapi_startkit/exceptions/handlers/DumpExceptionHandler.py

@@ -0,0 +1,104 @@
+import inspect
+import os
+
+from ...utils.filesystem import get_module_dir
+
+
+def is_property(obj):
+    return not inspect.ismethod(obj)
+
+
+def is_local(obj_name, obj):
+    return (
+        not obj_name.startswith("__")
+        and not obj_name.endswith("__")
+        and not type(obj).__name__ == "builtin_function_or_method"
+    )
+
+
+def serialize_property(obj):
+    if isinstance(obj, list):
+        local_list = []
+        for subobj in obj:
+            local_list.append(serialize_property(subobj))
+        return local_list
+    elif isinstance(obj, dict):
+        local_dict = {}
+        for key, val in obj.items():
+            local_dict.update({key: serialize_property(val)})
+        return local_dict
+    elif hasattr(obj, "serialize"):
+        return obj.serialize()
+    else:
+        return str(obj)
+
+
+class DumpExceptionHandler:
+    def __init__(self, application):
+        self.application = application
+
+        self.assets_path = os.path.join(
+            get_module_dir(__file__), "../../templates/assets"
+        )
+        self.styles = []
+        self.scripts = []
+
+    def add_style(self, file):
+        with open(os.path.join(self.assets_path, file), "r") as f:
+            self.styles.append(f.read())
+
+    def add_script(self, file):
+        with open(os.path.join(self.assets_path, file), "r") as f:
+            self.scripts.append(f.read())
+
+    def get_scripts(self):
+        scripts_str = ""
+        for script in self.scripts:
+            scripts_str += f"<script>{script}</script>\n"
+        return scripts_str
+
+    def get_styles(self):
+        styles_str = ""
+        for style in self.styles:
+            styles_str += f"<style>{style}</style>\n"
+        return styles_str
+
+    def handle(self, exception):
+        dumps = []
+        # for dump in self.application.make("dumper").get_dumps():
+        # for obj_name, obj in dump.objects.items():
+        # all_members = inspect.getmembers(obj, predicate=inspect.ismethod)
+        # all_properties = inspect.getmembers(obj, predicate=is_property)
+        # members = {
+        #     name: str(member)
+        #     for name, member in all_members
+        #     if is_local(name, member)
+        # }
+        # properties = {
+        #     name: serialize_property(prop)
+        #     for name, prop in all_properties
+        #     if is_local(name, prop)
+        # }
+        # dumps.append(
+        #     {
+        #         "name": obj_name,
+        #         "obj": str(obj),
+        #         "members": members,
+        #         "properties": properties,
+        #     }
+        # )
+        dumps = self.application.make("dumper").get_serialized_dumps()
+        self.add_style("tailwind.css")
+        self.add_style("github-dark.min.css")
+        self.add_script("highlight.min.js")
+
+        return self.application.make("response").view(
+            self.application.make("view").render(
+                "/masonite/templates/dump",
+                {
+                    "styles": self.get_styles(),
+                    "scripts": self.get_scripts(),
+                    "dumps": dumps,
+                },
+            )
+        )

fastapi_startkit/exceptions/handlers/HttpExceptionHandler.py

@@ -0,0 +1,28 @@
+class HttpExceptionHandler:
+    def __init__(self, application):
+        self.application = application
+
+    def handle(self, exception):
+        status_code = exception.get_status()
+        view_name = f"errors/{status_code}"
+        response = self.application.make("response")
+        request = self.application.make("request")
+
+        if request.accepts_json():
+            payload = {
+                "status": exception.get_status(),
+                "message": exception.get_response(),
+            }
+            return response.json(payload, status_code)
+
+        # Renders HTTP exception as HTML with predefined error page if exists
+        if self.application.make("view").exists(view_name):
+            return response.view(
+                self.application.make("view").render(
+                    f"errors/{status_code}", {"message": exception.get_response()}
+                ),
+                status_code,
+            )
+        else:
+            # Else render the exception without using template
+            return response.view(exception.get_response(), status_code)

fastapi_startkit/exceptions/handlers/ModelNotFoundHandler.py

@@ -0,0 +1,13 @@
+from ..exceptions import ModelNotFoundException
+
+
+class ModelNotFoundHandler:
+    def __init__(self, application):
+        self.application = application
+
+    def handle(self, exception):
+        masonite_exception = ModelNotFoundException(
+            "No record found with the given primary key"
+        )
+        self.application.make("response").status(404)
+        self.application.make("exception_handler").handle(masonite_exception)

fastapi_startkit/facades/Auth.py

@@ -0,0 +1,5 @@
+from .Facade import Facade
+
+
+class Auth(metaclass=Facade):
+    key = "auth"

fastapi_startkit/facades/Auth.pyi

@@ -0,0 +1,32 @@
+from typing import TYPE_CHECKING, Any, Tuple, List
+
+if TYPE_CHECKING:
+    from ..routes import Route
+
+class Auth:
+    """Authentication facade."""
+
+    def add_guard(name: str, guard: Any): ...
+    def set_configuration(config: dict): ...
+    def guard(guard: Any) -> "Auth": ...
+    def get_guard(name: str = None) -> Any: ...
+    def get_config_options(guard: Any = None) -> dict: ...
+    def attempt(email: str, password: str, once: bool = False) -> Any: ...
+    def attempt_by_id(user_id: int, once: bool = False) -> Any: ...
+    def logout(self) -> "Auth":
+        """Logout the current authenticated user."""
+        ...
+    def user(self) -> Any:
+        """Get the current authenticated user."""
+        ...
+    def register(dictionary: dict) -> Any:
+        """"""
+        ...
+    def password_reset(email: str) -> "Tuple[None, None]|Tuple[int,str]":
+        """Reset password of the user with the given email."""
+        ...
+    def reset_password(password: str, token: str) -> bool:
+        """Reset password of the user with the given authentication token."""
+        ...
+    @classmethod
+    def routes(self) -> List[Route]: ...

fastapi_startkit/facades/Broadcast.py

@@ -0,0 +1,5 @@
+from .Facade import Facade
+
+
+class Broadcast(metaclass=Facade):
+    key = "broadcast"

fastapi_startkit/facades/Cache.py

@@ -0,0 +1,5 @@
+from .Facade import Facade
+
+
+class Cache(metaclass=Facade):
+    key = "cache"

fastapi_startkit/facades/Config.py

@@ -0,0 +1,5 @@
+from .Facade import Facade
+
+
+class Config(metaclass=Facade):
+    key = "config"

fastapi_startkit/facades/Config.pyi

@@ -0,0 +1,14 @@
+from typing import Any
+
+class Config:
+    """Configuration facades to manage Masonite config files."""
+
+    def get(key: str, default: None) -> Any:
+        """Get given key in config, can use a dotted path."""
+        ...
+    def set(key: str, value: Any) -> None:
+        """Override config for given key."""
+        ...
+    def all(self) -> dict:
+        """Get all config object."""
+        ...

fastapi_startkit/facades/Dump.py

@@ -0,0 +1,5 @@
+from .Facade import Facade
+
+
+class Dump(metaclass=Facade):
+    key = "dumper"

fastapi_startkit/facades/Dump.pyi

@@ -0,0 +1,26 @@
+from typing import Any, List, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ..dumps import Dump as DumpObject
+
+class Dump:
+    """Dumper facade."""
+
+    def clear(self) -> "Dump":
+        """Clear all dumped data"""
+        ...
+    def dd(*objects: List[Any]):
+        """Dump all provided args and die, raising a DumpException."""
+        ...
+    def dump(*objects: List[Any]):
+        """Dump all provided args and continue code execution. This does not raise a DumpException."""
+        ...
+    def get_dumps(ascending: bool = False) -> List[DumpObject]:
+        """Get all dumps as Dump objects. If ascending is True, get dumps from oldest to most recents."""
+        ...
+    def last(self) -> DumpObject:
+        """Return last added dump."""
+        ...
+    def get_serialized_dumps(ascending: bool = False) -> List[dict]:
+        """Get all dumps as dict. If ascending is True, sort dumps from oldest to most recents."""
+        ...

fastapi_startkit/facades/Facade.py

@@ -0,0 +1,5 @@
+class Facade(type):
+    def __getattr__(self, attribute, *args, **kwargs):
+        from wsgi import application
+
+        return getattr(application.make(self.key), attribute)

fastapi_startkit/facades/Gate.py

@@ -0,0 +1,5 @@
+from .Facade import Facade
+
+
+class Gate(metaclass=Facade):
+    key = "gate"

fastapi_startkit/facades/Gate.pyi

@@ -0,0 +1,32 @@
+from typing import TYPE_CHECKING, Callable, List, Tuple, Any
+
+if TYPE_CHECKING:
+    from ..authorization import AuthorizationResponse, Policy, Gate as GateObject
+
+class Gate:
+    """Gate facade."""
+
+    def define(permission: str, condition: Callable): ...
+    def register_policies(policies: List[Tuple[Any, Policy]]) -> "Gate": ...
+    def get_policy_for(instance_or_class: "str|Any") -> "None|Policy": ...
+    def before(before_callback: Callable): ...
+    def after(after_callback: Callable): ...
+    def allows(permission: str, *args) -> bool: ...
+    def denies(permission, *args) -> bool: ...
+    def has(permission: str) -> bool: ...
+    def for_user(user: Any) -> GateObject: ...
+    def any(permissions: List[str], *args) -> bool:
+        """Check that every of those permissions are allowed."""
+        ...
+    def none(permissions: List[str], *args) -> bool:
+        """Check that none of those permissions are allowed."""
+        ...
+    def authorize(permission: str, *args) -> bool: ...
+    def inspect(permission: str, *args) -> "bool|AuthorizationResponse":
+        """Get permission checks results for the given user then builds and returns an
+        authorization response."""
+        ...
+    def check(permission: str, *args):
+        """The core of the authorization class. Run before() checks, permission check and then
+        after() checks."""
+        ...

fastapi_startkit/facades/Hash.py

@@ -0,0 +1,5 @@
+from .Facade import Facade
+
+
+class Hash(metaclass=Facade):
+    key = "hash"

fastapi_startkit/facades/Hash.pyi

@@ -0,0 +1,28 @@
+from typing import Any
+
+class Hash:
+    def add_driver(name: str, driver: Any): ...
+    def set_configuration(config: dict) -> "Hash": ...
+    def get_driver(name: str = None) -> Any: ...
+    def get_config_options(driver: str = None) -> dict: ...
+    def make(string: str, options: dict = {}, driver: str = None) -> str:
+        """Hash a string and return as string based on configured hashing protocol."""
+        ...
+    def make_bytes(string: str, options: dict = {}, driver: str = None) -> bytes:
+        """Hash a string and return as bytes based on configured hashing protocol."""
+        ...
+    def check(
+        self,
+        plain_string: str,
+        hashed_string: str,
+        options: dict = {},
+        driver: str = None,
+    ) -> bool:
+        """Verify that a given string matches its hashed version (based on configured hashing protocol)."""
+        ...
+    def needs_rehash(
+        hashed_string: str, options: dict = {}, driver: str = None
+    ) -> bool:
+        """Verify that a given hash needs to be hashed again because parameters for generating
+        the hash have changed."""
+        ...

fastapi_startkit/facades/Loader.py

@@ -0,0 +1,5 @@
+from .Facade import Facade
+
+
+class Loader(metaclass=Facade):
+    key = "loader"

fastapi_startkit/facades/Loader.pyi

@@ -0,0 +1,30 @@
+from typing import Any
+
+class Loader:
+    def get_modules(files_or_directories: list, raise_exception: bool = False) -> dict:
+        """Get a list of Python modules found (recursively) in the given list of files or directories.
+        If raise_exception is enabled it will raise an exception in case of error during loading a module."""
+    def find(
+        class_instance: Any,
+        paths: list,
+        class_name: str,
+        raise_exception: bool = False,
+    ) -> "None|Any": ...
+    def find_all(
+        class_instance: Any, paths: list, raise_exception: bool = False
+    ) -> dict: ...
+    def get_object(
+        path_or_module: "str|Any", object_name: str, raise_exception: bool = False
+    ) -> Any:
+        """Load the given object from a Python module located at path and returns a default value if
+        not found. If no object name is provided, returns the loaded module."""
+        ...
+    def get_objects(
+        path_or_module: "str|Any",
+        filter_method: callable = None,
+        raise_exception: bool = False,
+    ) -> dict:
+        """Returns a dictionary of objects from the given path (file or dotted). The dictionary can
+        be filtered if a given callable is given."""
+        ...
+    def get_parameters(module_or_path: "str|Any") -> dict: ...

fastapi_startkit/facades/Mail.py

@@ -0,0 +1,5 @@
+from .Facade import Facade
+
+
+class Mail(metaclass=Facade):
+    key = "mail"

fastapi_startkit/facades/Mail.pyi

@@ -0,0 +1,14 @@
+from typing import Any, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ..mail import Mailable
+
+class Mail:
+    """Mail facade."""
+
+    def add_driver(name: str, driver: Any): ...
+    def set_configuration(config: dict) -> "Mail": ...
+    def get_driver(name: str = None) -> Any: ...
+    def get_config_options(driver: str = None) -> dict: ...
+    def mailable(mailable: "Mailable") -> "Mail": ...
+    def send(driver: str = None): ...

fastapi_startkit/facades/Notification.py

@@ -0,0 +1,5 @@
+from .Facade import Facade
+
+
+class Notification(metaclass=Facade):
+    key = "notification"

fastapi_startkit/facades/Notification.pyi

@@ -0,0 +1,25 @@
+from typing import Any, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ..notification import Notification as NotificationObject
+
+class Notification:
+    """Notification handler facade, which handle sending/queuing notifications anonymously
+    or to notifiables through different channels."""
+
+    def add_driver(name: str, driver: str): ...
+    def get_driver(name: str) -> Any: ...
+    def set_configuration(config: dict) -> "Notification": ...
+    def get_config_options(driver: str) -> dict: ...
+    def send(
+        notifiables: list,
+        notification: "NotificationObject",
+        drivers: list = [],
+        dry: bool = False,
+        fail_silently: bool = False,
+    ) -> Any:
+        """Send the given notification to the given notifiables."""
+        ...
+    def route(driver: str, route: str) -> Any:
+        """Specify how to send a notification to an anonymous notifiable."""
+        ...

fastapi_startkit/facades/Queue.py

@@ -0,0 +1,5 @@
+from .Facade import Facade
+
+
+class Queue(metaclass=Facade):
+    key = "queue"

fastapi_startkit/facades/Queue.pyi

@@ -0,0 +1,10 @@
+from typing import Any
+
+class Queue:
+    def add_driver(name: str, driver: str): ...
+    def get_driver(name: str) -> Any: ...
+    def set_configuration(config: dict) -> "Queue": ...
+    def get_config_options(driver: str) -> dict: ...
+    def push(*jobs, **options) -> None: ...
+    def consume(options: dict) -> Any: ...
+    def retry(options: dict) -> Any: ...

fastapi_startkit/facades/RateLimiter.py

@@ -0,0 +1,5 @@
+from .Facade import Facade
+
+
+class RateLimiter(metaclass=Facade):
+    key = "rate"

fastapi_startkit/facades/RateLimiter.pyi

@@ -0,0 +1,43 @@
+from typing import Any, Callable, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ..rates.limiters import Limiter
+
+class RateLimiter:
+    """Rate Limiter facades to add rate limiting to your functions."""
+
+    def register(self, name, callback: "Limiter") -> "RateLimiter":
+        """Register a new rate limiter with the given name"""
+        ...
+    def attempts(self, key: str) -> int:
+        """Get number of attempts left for a given rate limiter key."""
+        ...
+    def get_limiter(self, name: str) -> "Limiter":
+        """Get rate limiter registered with the given name."""
+        ...
+    def attempt(
+        key: str, callback: Callable, max_attempts: int, delay: int = 60
+    ) -> Any:
+        """Try to execute the given callback if not limited by the 'key' rate limiter."""
+        ...
+    def too_many_attempts(self, key: str, max_attempts: int) -> bool:
+        """Check if given rate limiter key got more (or equal) attempts than max_attempts."""
+        ...
+    def hit(self, key: str, delay: int) -> int:
+        """Add one attempt for the given key."""
+        ...
+    def reset_attempts(self, key: str) -> bool:
+        """Reset attempts count to 0 for the given key."""
+        ...
+    def clear(self, key: str):
+        """Clear all data of the given rate limiter key."""
+        ...
+    def available_at(self, key: str) -> int:
+        """Get UNIX integer timestamp at which rate limiter key will be available again."""
+        ...
+    def available_in(self, key: str) -> int:
+        """Get seconds in which rate limiter key will be available again."""
+        ...
+    def remaining(self, key: str, max_attempts: int) -> int:
+        """Get remaining attempts before given rate limiter key is limited regarding max_attempts limit."""
+        ...

fastapi_startkit/facades/Request.py

@@ -0,0 +1,5 @@
+from .Facade import Facade
+
+
+class Request(metaclass=Facade):
+    key = "request"

fastapi_startkit/facades/Request.pyi

@@ -0,0 +1,88 @@
+from typing import TYPE_CHECKING, List, Any
+
+if TYPE_CHECKING:
+    from ..routes import Route
+
+class Request:
+    """Request facade."""
+
+    def load():
+        """Load request from environment."""
+        ...
+    def load_params(params: dict = None):
+        """Load request parameters."""
+        ...
+    def param(param: str, default: str = "") -> str:
+        """Get query string parameter from request."""
+        ...
+    def get_route() -> "Route":
+        """Get Route associated to request if any."""
+        ...
+    def get_path() -> str:
+        """Get request path (read from PATH_INFO) environment variable without eventual query
+        string parameters."""
+        ...
+    def get_path_with_query() -> str:
+        """Get request path (read from PATH_INFO) environment variable with eventual query
+        string parameters."""
+        ...
+    def get_back_path() -> str:
+        """Get previous request path if it has been defined as '__back' input."""
+        ...
+    def get_request_method() -> str:
+        """Get request method (read from REQUEST_METHOD environment variable)."""
+        ...
+    def input(name: str, default: str = "") -> str:
+        """Get a specific request input value with the given name. If the value does not exist in
+        the request return the default value."""
+        ...
+    def cookie(name: str, value: str = None, **options) -> None:
+        """If no value provided, read the cookie value with the given name from the request. Else
+        create a cookie in the request with the given name and value.
+        Some options can be passed when creating cookie, refer to CookieJar class."""
+        ...
+    def delete_cookie(name: str) -> "Request":
+        """Delete cookie with the given name from the request."""
+        ...
+    def header(name: str, value: str = None) -> "str|None":
+        """If no value provided, read the header value with the given name from the request. Else
+        add a header in the request with the given name and value."""
+        ...
+    def all() -> dict:
+        """Get all inputs from the request as a dictionary."""
+        ...
+    def only(*inputs: List[str]) -> dict:
+        """Get only the given inputs from the request as a dictionary."""
+        ...
+    def old(key: str):
+        """Get value from session for the given key."""
+        ...
+    def is_not_safe() -> bool:
+        """Check if the current request is considered 'safe', meaning that the request method is
+        GET, OPTIONS or HEAD."""
+        ...
+    def user() -> "None|Any":
+        """Get the current authenticated user if any. LoadUserMiddleware needs to be used for user
+        to be populated in request."""
+        ...
+    def set_user(user: Any) -> "Request":
+        """Set the current authenticated user of the request."""
+        ...
+    def remove_user() -> "Request":
+        """Log out user of the current request."""
+        ...
+    def contains(route: str) -> bool:
+        """Check if current request path match the given URL."""
+        ...
+    def get_subdomain(exclude_www: bool = True) -> "None|str":
+        """Get the request subdomain if subdomains are enabled."""
+        ...
+    def get_host() -> str:
+        """Get the request host (from HTTP_HOST environment variable)."""
+        ...
+    def activate_subdomains():
+        """Enable subdomains for this request."""
+        ...
+    def is_ajax() -> bool:
+        """Check if the current request is an AJAX request."""
+        ...

fastapi_startkit/facades/Response.py

@@ -0,0 +1,5 @@
+from .Facade import Facade
+
+
+class Response(metaclass=Facade):
+    key = "response"