fastapi-startkit 0.1.0__py3-none-any.whl

fastapi_startkit/environment/environment.py

@@ -0,0 +1,76 @@
+"""Module for the LoadEnvironment class."""
+
+import os
+import sys
+from pathlib import Path
+
+
+class LoadEnvironment:
+    """This class is used for loading the environment from .env and .env.* files."""
+
+    def __init__(self, environment=None, override=True, only=None, base_path=None):
+        """LoadEnvironment constructor.
+
+        Keyword Arguments:
+            env {string} -- An additional environment file that you want to load. (default: {None})
+            override {bool} -- Whether or not the environment variables found should overwrite existing ones. (default: {False})
+            only {string} -- If this is set then it will only load that environment. (default: {None})
+            base_path {string} -- The base path to look for the environment file. (default: {None})
+        """
+        from dotenv import load_dotenv
+
+        self.env = load_dotenv
+        self.base_path = Path(base_path) if base_path else Path(".")
+
+        if only:
+            self._load_environment(only, override=override)
+            return
+
+        env_path = str(self.base_path / ".env")
+        self.env(env_path, override=override)
+
+        if os.environ.get("APP_ENV"):
+            self._load_environment(os.environ.get("APP_ENV"), override=override)
+        if environment:
+            self._load_environment(environment, override=override)
+
+        if "PYTEST_CURRENT_TEST" in os.environ:
+            self._load_environment("testing", override=override)
+
+    def _load_environment(self, environment, override=False):
+        """Load the environment depending on the env file.
+
+        Arguments:
+            environment {string} -- Name of the environment file to load from
+
+        Keyword Arguments:
+            override {bool} -- Whether the environment file should overwrite existing environment keys. (default: {False})
+        """
+        env_path = str(self.base_path / f".env.{environment}")
+        self.env(dotenv_path=env_path, override=override)
+
+
+def env(value, default="", cast=True):
+    """Helper to retrieve the value of an environment variable or returns
+    a default value. In addition, if type can be inferred then the value can be casted to the
+    inferred type."""
+    env_var = os.getenv(value, default)
+
+    if not cast:
+        return env_var
+
+    if env_var == "":
+        env_var = default
+
+    if isinstance(env_var, bool):
+        return env_var
+    elif env_var is None:
+        return None
+    elif env_var.isnumeric():
+        return int(env_var)
+    elif env_var in ("false", "False"):
+        return False
+    elif env_var in ("true", "True"):
+        return True
+    else:
+        return env_var

fastapi_startkit/exceptions/DD.py

@@ -0,0 +1,38 @@
+import inspect
+import warnings
+
+from .exceptions import DumpException
+
+
+warnings.warn(
+    "DD class will be removed in Masonite 5. Please use Dump facade instead.",
+    DeprecationWarning,
+)
+
+
+class DD:
+    def __init__(self, container):
+        self.app = container
+
+    def die_and_dump(self, *args):
+        """Dump all provided args and die, ie raise a DumpException."""
+        self.dump(*args)
+        raise DumpException
+
+    def dump(self, *args):
+        """Dump all provided args and let flow continue. This does not raise a DumpException."""
+        print(
+            inspect.stack()[1].function,
+            inspect.stack()[1].filename,
+            inspect.stack()[1].lineno,
+        )
+        if self.app.has("ObjDumpList"):
+            dump_list = self.app.make("ObjDumpList")
+        else:
+            dump_list = []
+        start = len(dump_list)
+        for i, obj in enumerate(args):
+            dump_name = f"ObjDump{start + i}"
+            self.app.bind(dump_name, obj)
+            dump_list.append(dump_name)
+        self.app.bind("ObjDumpList", dump_list)

fastapi_startkit/exceptions/ExceptionHandler.py

@@ -0,0 +1,76 @@
+class ExceptionHandler:
+    def __init__(self, application, driver_config=None):
+        self.application = application
+        self.drivers = {}
+        self.driver_config = driver_config or {}
+        self.options = {}
+
+    def set_options(self, options):
+        self.options = options
+        return self
+
+    def add_driver(self, name, driver):
+        self.drivers.update({name: driver})
+
+    def set_configuration(self, config):
+        self.driver_config = config
+        return self
+
+    def get_driver(self, name=None):
+        if name is None:
+            return self.drivers[self.driver_config.get("default")]
+        return self.drivers[name]
+
+    def get_config_options(self, driver=None):
+        if driver is None:
+            return self.driver_config[self.driver_config.get("default")]
+
+        return self.driver_config.get(driver, {})
+
+    def handle(self, exception):
+        response = self.application.make("response")
+        request = self.application.make("request")
+
+        self.application.make("event").fire(
+            f"masonite.exception.{exception.__class__.__name__}", exception
+        )
+
+        # add headers to response if any
+        if hasattr(exception, "get_headers"):
+            headers = exception.get_headers()
+            response.with_headers(headers)
+
+        # if an exception handler is registered for this exception, use it instead
+        # add headers to response if any
+        if hasattr(exception, "get_headers"):
+            headers = exception.get_headers()
+            response.with_headers(headers)
+
+        if self.application.has(f"{exception.__class__.__name__}Handler"):
+            return self.application.make(
+                f"{exception.__class__.__name__}Handler"
+            ).handle(exception)
+
+        # handle exception in production
+        if not self.application.is_debug():
+            # for HTTP error codes (500, 404, 403...) a specific page should be displayed
+            # if a renderable exception is raised let it be displayed
+            if hasattr(exception, "is_http_exception") or hasattr(
+                exception, "get_response"
+            ):
+                return self.application.make("HttpExceptionHandler").handle(exception)
+
+            # else fallback to an unknown exception that should be displayed as a 500 error
+            exception.get_status = lambda: 500
+            exception.get_response = lambda: str(exception) or "Unknown error"
+            return self.application.make("HttpExceptionHandler").handle(exception)
+
+        # handle exception in development mode with Exceptionite
+        exceptionite = self.get_driver("exceptionite")
+        exceptionite.start(exception)
+        exceptionite.render("terminal")
+
+        if request.accepts_json():
+            return response.view(exceptionite.render("json"), status=500)
+        else:
+            return response.view(exceptionite.render("web"), status=500)

fastapi_startkit/exceptions/__init__.py

@@ -0,0 +1,38 @@
+from .ExceptionHandler import ExceptionHandler
+from .handlers.DumpExceptionHandler import DumpExceptionHandler
+from .handlers.HttpExceptionHandler import HttpExceptionHandler
+from .handlers.ModelNotFoundHandler import ModelNotFoundHandler
+from .DD import DD
+from .exceptions import (
+    AuthorizationException,
+    InvalidRouteCompileException,
+    RouteMiddlewareNotFound,
+    ContainerError,
+    MissingContainerBindingNotFound,
+    StrictContainerException,
+    ResponseError,
+    InvalidHTTPStatusCode,
+    RequiredContainerBindingNotFound,
+    ViewException,
+    RouteNotFoundException,
+    DumpException,
+    InvalidSecretKey,
+    InvalidCSRFToken,
+    NotificationException,
+    InvalidToken,
+    ProjectLimitReached,
+    ProjectProviderTimeout,
+    ProjectProviderHttpError,
+    ProjectTargetNotEmpty,
+    MixFileNotFound,
+    MixManifestNotFound,
+    InvalidConfigurationLocation,
+    InvalidConfigurationSetup,
+    InvalidPackageName,
+    LoaderNotFound,
+    QueueException,
+    AmbiguousError,
+    MethodNotAllowedException,
+    ModelNotFoundException,
+    ThrottleRequestsException,
+)

fastapi_startkit/exceptions/exceptionite/blocks.py

@@ -0,0 +1,101 @@
+from exceptionite import Block
+
+from ... import __version__
+from ...helpers import optional
+from ...utils.str import get_controller_name
+
+
+def recursive_serializer(data):
+    if isinstance(data, (int, bool, str, bytes)):
+        return data
+    elif isinstance(data, (list, tuple)):
+        return [recursive_serializer(item) for item in data]
+    elif isinstance(data, dict):
+        return {key: recursive_serializer(val) for key, val in data.items()}
+    elif callable(data):
+        return str(data)
+    elif hasattr(data, "serialize"):
+        return data.serialize()
+    else:
+        return str(data)
+
+
+class AppBlock(Block):
+    id = "application"
+    name = "Application"
+    icon = "DesktopComputerIcon"
+    has_sections = True
+
+    def build(self):
+        request = self.handler.app.make("request")
+        route = request.get_route()
+
+        data = {
+            "Info": {
+                "Masonite Version": __version__,
+                "Environment": self.handler.app.environment(),
+                "Debug": self.handler.app.is_debug(),
+            }
+        }
+
+        # add app route data
+        if route:
+            data.update(
+                {
+                    "Route": {
+                        "Controller": get_controller_name(route.controller),
+                        "Name": route.get_name(),
+                        "Middlewares": route.get_middlewares(),
+                    }
+                }
+            )
+
+        # add user route data
+        user = request.user()
+        if user:
+            data.update(
+                {
+                    "User": {
+                        "E-mail": optional(user).email,
+                        "ID": optional(user).id,
+                    }
+                }
+            )
+
+        return data
+
+
+class RequestBlock(Block):
+    id = "request"
+    name = "Request"
+    icon = "SwitchHorizontalIcon"
+    has_sections = True
+
+    def build(self):
+        request = self.handler.app.make("request")
+        # serialize inputs (e.g. in case of file)
+        inputs = {}
+        for name, value in request.all().items():
+            inputs[name] = recursive_serializer(value)
+        return {
+            "Parameters": {
+                "Path": request.get_path(),
+                "Input": inputs or None,
+                "Request Method": request.get_request_method(),
+            },
+            "Headers": request.header_bag.to_dict(),
+        }
+
+
+class ConfigBlock(Block):
+    id = "config"
+    name = "Configuration"
+    icon = "CogIcon"
+    has_sections = True
+
+    def build(self):
+        data = {}
+        for section, config_data in self.handler.app.make("config").all().items():
+            section_name = section.title()
+            data[section_name] = recursive_serializer(config_data)
+        return data

fastapi_startkit/exceptions/exceptionite/controllers.py

@@ -0,0 +1,13 @@
+from ...request import Request
+from ...controllers import Controller
+from ...response import Response
+
+
+class ExceptioniteController(Controller):
+    def run_action(self, request: Request, response: Response):
+        handler = request.app.make("exception_handler").get_driver("exceptionite")
+        data = handler.run_action(request.input("action_id"), request.input("options"))
+        try:
+            return response.json({"message": "ok", "data": data}, 200)
+        except:  # noqa: E722
+            return response.json({"message": "An error happened", "data": data}, 400)

fastapi_startkit/exceptions/exceptionite/solutions.py

@@ -0,0 +1,66 @@
+class TableNotFound:
+    def title(self):
+        return "Table Not Found"
+
+    def description(self):
+        return "You are trying to make a query on a table that cannot be found. Check that :table migration exists and that migrations have been ran with 'python craft migrate' command."
+
+    def regex(self):
+        return r"no such table: (?P<table>(\w+))"
+
+
+class MissingCSRFToken:
+    def title(self):
+        return "Missing CSRF Token"
+
+    def description(self):
+        return "You are trying to make a sensitive request without providing a CSRF token. Your request might be vulnerable to Cross Site Request Forgery. To resolve this issue you should use {{ csrf_field }} in HTML forms or add X-CSRF-TOKEN header in AJAX requests."
+
+    def regex(self):
+        return r"Missing CSRF Token"
+
+
+class InvalidCSRFToken:
+    def title(self):
+        return "The session does not match the CSRF token"
+
+    def description(self):
+        return "Try clearing your cookies for the localhost domain in your browsers developer tools."
+
+    def regex(self):
+        return r"Invalid CSRF Token"
+
+
+class TemplateNotFound:
+    def title(self):
+        return "Template Not Found"
+
+    def description(self):
+        return """':template.html' view file has not been found in registered view locations. Please verify the spelling of the template and that it exists in locations declared in Kernel file. You can check
+        available view locations with app.make('view.locations')."""
+
+    def regex(self):
+        return r"Template '(?P<template>(\w+))' not found"
+
+
+class NoneResponse:
+    def title(self):
+        return "Response cannot be None"
+
+    def description(self):
+        return """Ensure that the controller method used in this request returned something. A controller method cannot return None or nothing.
+        If you don't want to return a value you can return an empty string ''."""
+
+    def regex(self):
+        return r"Responses cannot be of type: None."
+
+
+class RouteMiddlewareNotFound:
+    def title(self):
+        return "Did you register the middleware key in your Kernel.py file?"
+
+    def description(self):
+        return "Check your Kernel.py file inside your 'route_middleware' attribute and look for a :middleware key"
+
+    def regex(self):
+        return r"Could not find the \'(?P<middleware>(\w+))\' middleware key"

fastapi_startkit/exceptions/exceptionite/tabs.py

@@ -0,0 +1,19 @@
+from exceptionite import Tab
+
+
+class DumpsTab(Tab):
+    id = "dumps"
+    name = "Dumps"
+    component = "DumpsTab"
+    icon = "CodeIcon"
+    advertise_content = True
+    empty_msg = "Nothing dumped !"
+
+    def build(self):
+        dumps = self.handler.app.make("dumper").get_serialized_dumps()
+        return {
+            "dumps": dumps,
+        }
+
+    def has_content(self):
+        return len(self.handler.app.make("dumper").get_dumps()) > 0

fastapi_startkit/exceptions/exceptions.py

@@ -0,0 +1,218 @@
+class DriverNotFound(Exception):
+    pass
+
+
+class DriverLibraryNotFound(Exception):
+    pass
+
+
+class FileTypeException(Exception):
+    pass
+
+
+class RequiredContainerBindingNotFound(Exception):
+    pass
+
+
+class MissingContainerBindingNotFound(Exception):
+    pass
+
+
+class UnacceptableDriverType(Exception):
+    pass
+
+
+class ContainerError(Exception):
+    pass
+
+
+class InvalidCSRFToken(Exception):
+    pass
+
+
+class InvalidHTTPStatusCode(Exception):
+    pass
+
+
+class RouteMiddlewareNotFound(Exception):
+    pass
+
+
+class ResponseError(Exception):
+    pass
+
+
+class InvalidAutoloadPath(Exception):
+    pass
+
+
+class AutoloadContainerOverwrite(Exception):
+    pass
+
+
+class InvalidSecretKey(Exception):
+    pass
+
+
+class InvalidToken(Exception):
+    pass
+
+
+class StrictContainerException(Exception):
+    pass
+
+
+class InvalidRouteCompileException(Exception):
+    pass
+
+
+class RouteException(Exception):
+    pass
+
+
+class RouteNotFoundException(Exception):
+    is_http_exception = True
+
+    def __init__(self, message):
+        super().__init__(message)
+        self.message = message or "Route Not Found"
+
+    def get_response(self):
+        return self.message
+
+    def get_status(self):
+        return 404
+
+
+class MethodNotAllowedException(Exception):
+    is_http_exception = True
+
+    def __init__(self, allowed_methods, method):
+        allowed_list = ", ".join(allowed_methods)
+        message = f"{method} method not allowed for this route. Supported methods are: {allowed_list}."
+        super().__init__(message)
+        self.message = message
+        self.headers = {"Allow": allowed_list}
+
+    def get_response(self):
+        return self.message
+
+    def get_headers(self):
+        return self.headers
+
+    def get_status(self):
+        return 405
+
+
+class DebugException(Exception):
+    pass
+
+
+class DumpException(Exception):
+    pass
+
+
+class ViewException(Exception):
+    pass
+
+
+class QueueException(Exception):
+    pass
+
+
+class AmbiguousError(Exception):
+    pass
+
+
+class ProjectLimitReached(Exception):
+    pass
+
+
+class ProjectProviderTimeout(Exception):
+    pass
+
+
+class ProjectProviderHttpError(Exception):
+    pass
+
+
+class ProjectTargetNotEmpty(Exception):
+    pass
+
+
+class NotificationException(Exception):
+    pass
+
+
+class ModelNotFoundException(Exception):
+    is_http_exception = True
+
+    def get_response(self):
+        return "Model Not Found"
+
+    def get_status(self):
+        return 404
+
+
+class AuthorizationException(Exception):
+    is_http_exception = True
+
+    def __init__(self, message="", status=403):
+        super().__init__(message)
+        self.message = message or "Action not authorized"
+        self.status = status or 403
+
+    def get_response(self):
+        return self.message
+
+    def get_status(self):
+        return self.status
+
+
+class ThrottleRequestsException(Exception):
+    def __init__(self, message="Too many attempts", status=429, headers={}):
+        super().__init__(message)
+        self.message = message
+        self.status = status
+        self.headers = headers
+
+    def get_headers(self):
+        return self.headers
+
+    def get_response(self):
+        return self.message
+
+    def get_status(self):
+        return self.status
+
+
+class GateDoesNotExist(Exception):
+    pass
+
+
+class PolicyDoesNotExist(Exception):
+    pass
+
+
+class MixManifestNotFound(Exception):
+    pass
+
+
+class MixFileNotFound(Exception):
+    pass
+
+
+class InvalidConfigurationLocation(Exception):
+    pass
+
+
+class InvalidConfigurationSetup(Exception):
+    pass
+
+
+class InvalidPackageName(Exception):
+    pass
+
+
+class LoaderNotFound(Exception):
+    pass