fastapi-startkit 0.1.0__py3-none-any.whl

fastapi_startkit/facades/Response.pyi

@@ -0,0 +1,68 @@
+from typing import Any
+
+class Response:
+    """Response facade."""
+
+    def json(payload: Any, status: int = 200) -> bytes:
+        """Set the response as a JSON response."""
+        ...
+    def make_headers(content_type: str = "text/html; charset=utf-8") -> None:
+        """Recompute Content-Length of the response after modyifing it."""
+        ...
+    def header(name: str, value: str = None) -> "None|str":
+        """Get response header for the given name if no value provided or add headers to response."""
+        ...
+    def get_headers(self) -> list:
+        """Get all response headers."""
+        ...
+    def cookie(name: str, value: str = None, **options) -> "None|str":
+        """Get response cookie for the given name if no value provided or add cookie to
+        the response with the given name, value and options."""
+        ...
+    def delete_cookie(name: str) -> "Response":
+        """Delete the cookie with the given name from the response."""
+        ...
+    def get_response_content(self) -> bytes:
+        """Get response content."""
+        ...
+    def status(status: "str|int") -> "Response":
+        """Set HTTP status code of the response."""
+        ...
+    def is_status(code: int) -> bool:
+        """Check if response has the given status code."""
+        ...
+    def get_status_code(self) -> str:
+        """Gets the HTTP status code of the response as a human string, like "200 OK"."""
+        ...
+    def get_status(self): ...
+    def data(self) -> bytes:
+        """Get the response content as bytes."""
+        ...
+    def converted_data(self) -> "str|bytes":
+        """Get the response content as string or bytes so that the WSGI server handles it."""
+        ...
+    def view(view: Any, status: int = 200) -> "bytes|Response":
+        """Set the response as a string or view."""
+        ...
+    def back(self) -> "Response":
+        """Set the response as a redirect response back to previous path defined from the
+        request."""
+        ...
+    def redirect(
+        location: str = None,
+        name: str = None,
+        params: dict = {},
+        url: str = None,
+        status: int = 302,
+    ) -> "Response":
+        """Set the response as a redirect response. The redirection location can be defined
+        with the location URL or with a route name. If a route name is used, route params can
+        be provided."""
+
+        ...
+    def to_bytes(self) -> "bytes":
+        """Converts the response to bytes."""
+        ...
+    def download(name: str, location: str, force: bool = False) -> "Response":
+        """Set the response as a file download response."""
+        ...

fastapi_startkit/facades/Session.py

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

fastapi_startkit/facades/Session.pyi

@@ -0,0 +1,59 @@
+from typing import Any
+
+class Session:
+    """Session facade."""
+
+    def add_driver(name: str, driver: Any) -> None:
+        """Register a new session driver with the given name."""
+        ...
+    def driver(driver: str) -> Any:
+        """Get a registered session driver with the given name."""
+        ...
+    def set_configuration(config: dict) -> "Session":
+        """Set session driver options."""
+        ...
+    def get_driver(name: str = None) -> Any:
+        """Get the default session driver or the driver with the given name."""
+        ...
+    def get_config_options(driver: str = None) -> dict:
+        """Get the options of the default session driver or of the driver with the given name."""
+        ...
+    def start(driver: str = None) -> "Session":
+        """Initialize session."""
+        ...
+    def get_data(self) -> dict:
+        """Get all session data."""
+        ...
+    def save(driver: str = None) -> None:
+        """Save session data for the default session driver or the given named driver."""
+        ...
+    def set(key: str, value: Any) -> None:
+        """Save value in default session."""
+        ...
+    def increment(key: str, count: int = 1) -> None:
+        """Increment session key with given count."""
+        ...
+    def decrement(key: str, count: int = 1) -> None:
+        """Decrement session key with given count."""
+        ...
+    def has(key: str) -> bool:
+        """Check if key is present in default session."""
+        ...
+    def get(key: str) -> Any:
+        """Get value of the given key in default session."""
+        ...
+    def pull(key: str) -> Any:
+        """Get and remove value for the given key in session."""
+        ...
+    def flush(self) -> None:
+        """Delete all keys from session."""
+        ...
+    def delete(key: str) -> "None|Any":
+        """Delete the given key from session."""
+        ...
+    def flash(key: str, value: Any) -> None:
+        """Save temporary value into session."""
+        ...
+    def all(self) -> dict:
+        """Get all session data."""
+        ...

fastapi_startkit/facades/Storage.py

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

fastapi_startkit/facades/Storage.pyi

@@ -0,0 +1,12 @@
+from typing import Any
+
+class Storage:
+    """File storage facade."""
+
+    def add_driver(name: str, driver: str): ...
+    def set_configuration(config: dict) -> "Storage": ...
+    def get_driver(name: str = None) -> Any: ...
+    def get_config_options(name: str = None) -> dict: ...
+    def disk(name: str = "default") -> Any:
+        """Get the file manager instance for the given disk name."""
+        ...

fastapi_startkit/facades/Url.py

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

fastapi_startkit/facades/Url.pyi

@@ -0,0 +1,22 @@
+class Url:
+    """URL helper facade."""
+
+    def url(path: str = "") -> str:
+        """Generates a fully qualified url to the given path. If no path is given this will return
+        the base url domain."""
+        ...
+    def asset(alias: str, filename: str) -> str:
+        """Generates a fully qualified URL for the given asset using the given disk
+        Example:
+            asset("local", "avatar.jpg") (take first pat)
+            asset("s3.private", "doc.pdf") (when multiple paths are specified for the disk)
+        """
+        ...
+    def route(name: str, params: dict = {}, absolute: bool = True) -> str:
+        """Generates a fully qualified URL to the given route name.
+        Example:
+            route("users.home") : http://masonite.app/dashboard/
+            route("users.profile", {"id": 1}) : http://masonite.app/users/1/profile/
+            route("users.profile", {"id": 1}, absolute=False) : /users/1/profile/
+        """
+        ...

fastapi_startkit/facades/View.py

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

fastapi_startkit/facades/View.pyi

@@ -0,0 +1,54 @@
+from typing import Callable, Any
+from jinja2 import PackageLoader, BaseLoader
+
+class View:
+    """View facade."""
+
+    def render(template: str, dictionary: dict = {}) -> "View":
+        """Render the given template name with the given context as string."""
+        ...
+    def get_content(self) -> str:
+        """Get the rendered content as string."""
+        ...
+    def hydrate_from_composers(self):
+        """Add data into the view from specified composers."""
+        ...
+    def composer(composer_name: str, dictionary: dict) -> "View":
+        """Add/Update composer with the given name and data."""
+        ...
+    def share(dictionary: dict) -> "View":
+        """Share data to all templates."""
+        ...
+    def exists(template: str) -> bool:
+        """Check if a template with the given name exists."""
+        ...
+    def add_location(template_location: str, loader: "BaseLoader" = PackageLoader):
+        """Add location directory from which view templates can be loaded. The Jinja2 loader type
+        can be specified."""
+        ...
+    def add_namespaced_location(namespace: str, template_location: str):
+        """Add namespaced location directory from which view templates can be loaded."""
+        ...
+    def add_from_package(package_name: str, path_in_package: str): ...
+    def filter(name: str, function: Callable):
+        """Add filter functions to views with the given name."""
+        ...
+    def add_extension(extension: str) -> "View":
+        """Register Jinja2 extension to views."""
+        ...
+    def load_template(template: str):
+        """Private method for loading all the locations into the current environment."""
+        ...
+    def get_current_loaders(self):
+        """Get all enabled Jinja2 loaders."""
+        ...
+    def set_separator(token: str) -> "View":
+        """Change separator for view names (default is /)."""
+        ...
+    def set_file_extension(extension: str) -> "View":
+        """Change file view extension (default is .html)."""
+        ...
+    def get_response(self) -> str:
+        """Get the rendered content as string."""
+        ...
+    def test(key: str, obj: Any) -> "View": ...

fastapi_startkit/facades/__init__.py

@@ -0,0 +1,19 @@
+from .Facade import Facade
+from .Request import Request
+from .Response import Response
+from .Mail import Mail
+from .Hash import Hash
+from .Url import Url
+from .Session import Session
+from .View import View
+from .Gate import Gate
+from .Auth import Auth
+from .Config import Config
+from .Loader import Loader
+from .Notification import Notification
+from .Storage import Storage
+from .Dump import Dump
+from .Queue import Queue
+from .Cache import Cache
+from .RateLimiter import RateLimiter
+from .Broadcast import Broadcast

fastapi_startkit/loader/Loader.py

@@ -0,0 +1,78 @@
+"""Loader class to easily list, find or load any object in a given module, or folder."""
+import inspect
+import pkgutil
+import os
+
+from ..exceptions import LoaderNotFound
+from ..utils.str import as_filepath
+from ..utils.structures import load
+
+
+def parameters_filter(obj_name, obj):
+    return (
+        obj_name.isupper()
+        and not obj_name.startswith("__")
+        and not obj_name.endswith("__")
+    )
+
+
+class Loader:
+    def get_modules(self, files_or_directories, raise_exception=False):
+        if not isinstance(files_or_directories, list):
+            files_or_directories = [files_or_directories]
+
+        _modules = {}
+        module_paths = list(map(as_filepath, files_or_directories))
+        for module_loader, name, _ in pkgutil.iter_modules(module_paths):
+            module = load(
+                f"{os.path.relpath(module_loader.path)}.{name}",
+                raise_exception=raise_exception,
+            )
+            _modules.update({name: module})
+        return _modules
+
+    def find(self, class_instance, paths, class_name, raise_exception=False):
+        _classes = self.find_all(class_instance, paths, raise_exception)
+        for name, obj in _classes.items():
+            if name == class_name:
+                return obj
+        if raise_exception:
+            raise LoaderNotFound(
+                f"No {class_instance} named {class_name} has been found in {paths}"
+            )
+        return None
+
+    def find_all(self, class_instance, paths, raise_exception=False):
+        _classes = {}
+        for module in self.get_modules(paths, raise_exception).values():
+            for obj_name, obj in inspect.getmembers(module):
+                # check if obj is the same class as the given one
+                if inspect.isclass(obj) and issubclass(obj, class_instance):
+                    # check if the class really belongs to those paths to load internal only
+                    if obj.__module__.startswith(module.__package__):
+                        _classes.update({obj_name: obj})
+        if not len(_classes.keys()) and raise_exception:
+            raise LoaderNotFound(f"No {class_instance} have been found in {paths}")
+        return _classes
+
+    def get_object(self, path_or_module, object_name, raise_exception=False):
+        return load(path_or_module, object_name, raise_exception=raise_exception)
+
+    def get_objects(self, path_or_module, filter_method=None, raise_exception=False):
+        """Returns a dictionary of objects from the given path (file or dotted). The dictionary can
+        be filtered if a given callable is given."""
+        if isinstance(path_or_module, str):
+            module = load(path_or_module, raise_exception=raise_exception)
+        else:
+            module = path_or_module
+        if not module:
+            return None
+        return dict(inspect.getmembers(module, filter_method))
+
+    def get_parameters(self, module_or_path):
+        _parameters = {}
+        for name, obj in self.get_objects(module_or_path).items():
+            if parameters_filter(name, obj):
+                _parameters.update({name: obj})
+
+        return _parameters

fastapi_startkit/loader/__init__.py

@@ -0,0 +1 @@
+from .Loader import Loader

fastapi_startkit/providers/ConfigurationProvider.py

@@ -0,0 +1,13 @@
+from .Provider import Provider
+from ..configuration import Configuration
+import os
+
+class ConfigurationProvider(Provider):
+    def register(self):
+        self.application.bind('config.location', os.path.join(self.application.base_path, "config"))
+        configuration = Configuration(self.application)
+        configuration.load()
+        self.application.bind("config", configuration)
+
+    def boot(self):
+        pass

fastapi_startkit/providers/Provider.py

@@ -0,0 +1,14 @@
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ..container import Container
+
+class Provider:
+    def __init__(self, application) -> None:
+        self.application = application
+
+    def register(self) -> None:
+        pass
+
+    def boot(self) -> None:
+        pass

fastapi_startkit/providers/__init__.py

@@ -0,0 +1,4 @@
+from .Provider import Provider
+from .ConfigurationProvider import ConfigurationProvider
+
+__all__ = ["Provider", "ConfigurationProvider"]