fastapi-startkit 0.28.0__tar.gz → 0.29.0__tar.gz

{fastapi_startkit-0.28.0 → fastapi_startkit-0.29.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: fastapi-startkit
-Version: 0.28.0
+Version: 0.29.0
 Summary: Fastapi Starter kit components
 Author: Bedram Tamang
 Author-email: Bedram Tamang <tmgbedu@gmail.com>

{fastapi_startkit-0.28.0 → fastapi_startkit-0.29.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fastapi-startkit"
-version = "0.28.0"
+version = "0.29.0"
 description = "Fastapi Starter kit components"
 authors = [
     {name = "Bedram Tamang", email = "tmgbedu@gmail.com"}
@@ -52,6 +52,7 @@ dev = [
     "dumpdie>=1.5.0",
     "pytest>=9.0.3",
     "pytest-asyncio>=1.3.0",
+    "pytest-cov>=6.0.0",
     "ruff>=0.9.0",
     "twine>=6.2.0",
     "itsdangerous>=2.2.0",
@@ -75,6 +76,30 @@ fixable = ["F401"]
 
 [tool.pytest.ini_options]
 asyncio_mode = "auto"
+norecursedirs = ["masoniteorm.backup", ".venv", "dist", "build", "__pycache__"]
+
+[tool.coverage.run]
+source = ["src/fastapi_startkit"]
+omit = [
+    "*/tests/*",
+    "*/migrations/*",
+    "*/__init__.py",
+    "*.pyi",
+]
+
+[tool.coverage.report]
+show_missing = true
+skip_covered = false
+fail_under = 50
+exclude_lines = [
+    "pragma: no cover",
+    "if TYPE_CHECKING:",
+    "raise NotImplementedError",
+    "@abstractmethod",
+]
+
+[tool.coverage.html]
+directory = "htmlcov"
 
 [build-system]
 requires = ["uv_build >= 0.10.10, <0.11.0"]

{fastapi_startkit-0.28.0 → fastapi_startkit-0.29.0}/src/fastapi_startkit/console/publish_command.py

@@ -4,7 +4,7 @@ from typing import TYPE_CHECKING
 
 from fastapi_startkit.console import Command
 from cleo.helpers import option
-from fastapi_startkit.helpers.string import Str
+from fastapi_startkit.support import Str
 
 if TYPE_CHECKING:
     from fastapi_startkit.application import Application

{fastapi_startkit-0.28.0 → fastapi_startkit-0.29.0}/src/fastapi_startkit/facades/__init__.py

@@ -7,7 +7,6 @@ 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
@@ -16,4 +15,3 @@ from .Queue import Queue
 from .Cache import Cache
 from .RateLimiter import RateLimiter
 from .Broadcast import Broadcast
-from .Inertia import Inertia

{fastapi_startkit-0.28.0 → fastapi_startkit-0.29.0}/src/fastapi_startkit/loader/Loader.py

@@ -4,7 +4,6 @@ import inspect
 import pkgutil
 
 from ..exceptions import LoaderNotFound
-from ..utils.str import as_filepath
 from ..utils.structures import load
 
 
@@ -18,7 +17,7 @@ class Loader:
             files_or_directories = [files_or_directories]
 
         _modules = {}
-        module_paths = list(map(as_filepath, files_or_directories))
+        module_paths = list(map(lambda p: p.replace(".", "/"), files_or_directories))
         for module_loader, name, _ in pkgutil.iter_modules(module_paths):
             module = load(
                 f"{module_loader.path}/{name}.py",

{fastapi_startkit-0.28.0 → fastapi_startkit-0.29.0}/src/fastapi_startkit/logging/channels/DailyChannel.py

@@ -1,8 +1,9 @@
-from ..factory import DriverFactory
-from fastapi_startkit.facades import Config
-from fastapi_startkit.utils.filesystem import make_directory
 import os
+
+from fastapi_startkit.facades import Config
 from .BaseChannel import BaseChannel
+from ..factory import DriverFactory
+from ..file import make_directory
 
 
 class DailyChannel(BaseChannel):

{fastapi_startkit-0.28.0 → fastapi_startkit-0.29.0}/src/fastapi_startkit/logging/channels/SingleChannel.py

@@ -1,6 +1,6 @@
 from ..factory import DriverFactory
 from fastapi_startkit.facades import Config
-from fastapi_startkit.utils.filesystem import make_directory
+from ..file import make_directory
 from .BaseChannel import BaseChannel
 
 

{fastapi_startkit-0.28.0 → fastapi_startkit-0.29.0}/src/fastapi_startkit/logging/channels/SyslogChannel.py

@@ -1,6 +1,6 @@
 from ..factory import DriverFactory
 from fastapi_startkit.facades import Config
-from fastapi_startkit.utils.filesystem import make_directory
+from ..file import make_directory
 from .BaseChannel import BaseChannel
 
 

{fastapi_startkit-0.28.0 → fastapi_startkit-0.29.0}/src/fastapi_startkit/logging/drivers/LogTerminalDriver.py

@@ -1,8 +1,18 @@
-# from logging import Logger
+from .BaseDriver import BaseDriver
 
-from fastapi_startkit.utils.console import HasColoredOutput
 
-from .BaseDriver import BaseDriver
+class HasColoredOutput:
+    def success(self, message):
+        print("\033[92m {0} \033[0m".format(message))
+
+    def warning(self, message):
+        print("\033[93m {0} \033[0m".format(message))
+
+    def danger(self, message):
+        print("\033[91m {0} \033[0m".format(message))
+
+    def info(self, message):
+        return self.success(message)
 
 
 class LogTerminalDriver(BaseDriver, HasColoredOutput):

fastapi_startkit-0.29.0/src/fastapi_startkit/logging/file.py

@@ -0,0 +1,13 @@
+import os
+
+
+def make_directory(directory):
+    """Create a directory at the given path for a file if it does not exist"""
+    if not os.path.isfile(directory):
+        if not os.path.exists(os.path.dirname(directory)):
+            # Create the path to the model if it does not exist
+            os.makedirs(os.path.dirname(directory))
+
+        return True
+
+    return False

{fastapi_startkit-0.28.0 → fastapi_startkit-0.29.0}/src/fastapi_startkit/masoniteorm/collection/Collection.py

@@ -1,4 +1,4 @@
-from fastapi_startkit.collection import Collection as BaseCollection
+from fastapi_startkit.support.collection import Collection as BaseCollection
 
 
 class Collection(BaseCollection):

{fastapi_startkit-0.28.0 → fastapi_startkit-0.29.0}/src/fastapi_startkit/masoniteorm/commands/MakeMigrationCommand.py

@@ -3,7 +3,7 @@ import os
 import pathlib
 from inflection import tableize
 from cleo.helpers import argument, option
-from fastapi_startkit.helpers.string import Str
+from fastapi_startkit.support import Str
 from fastapi_startkit.console import Command
 
 

{fastapi_startkit-0.28.0 → fastapi_startkit-0.29.0}/src/fastapi_startkit/masoniteorm/models/model.py

@@ -91,6 +91,110 @@ class Model(Attribute, Relationship, ObservesEvents):
     def with_(cls, *eagers) -> "QueryBuilder":
         return cls.query().with_(*eagers)
 
+    @classmethod
+    def where(cls, column, *args) -> "QueryBuilder":
+        return cls.query().where(column, *args)
+
+    @classmethod
+    def or_where(cls, column, *args) -> "QueryBuilder":
+        return cls.query().or_where(column, *args)
+
+    @classmethod
+    def where_null(cls, column: str) -> "QueryBuilder":
+        return cls.query().where_null(column)
+
+    @classmethod
+    def where_not_null(cls, column: str) -> "QueryBuilder":
+        return cls.query().where_not_null(column)
+
+    @classmethod
+    def where_in(cls, column: str, values) -> "QueryBuilder":
+        return cls.query().where_in(column, values)
+
+    @classmethod
+    def where_not_in(cls, column: str, values) -> "QueryBuilder":
+        return cls.query().where_not_in(column, values)
+
+    @classmethod
+    def select(cls, *args) -> "QueryBuilder":
+        return cls.query().select(*args)
+
+    @classmethod
+    def limit(cls, limit: int) -> "QueryBuilder":
+        return cls.query().limit(limit)
+
+    @classmethod
+    def offset(cls, offset: int) -> "QueryBuilder":
+        return cls.query().offset(offset)
+
+    @classmethod
+    def order_by(cls, column: str, direction: str = "asc") -> "QueryBuilder":
+        return cls.query().order_by(column, direction)
+
+    @classmethod
+    def order_by_raw(cls, expression: str) -> "QueryBuilder":
+        return cls.query().order_by_raw(expression)
+
+    @classmethod
+    def latest(cls, column: str = "created_at") -> "QueryBuilder":
+        return cls.query().latest(column)
+
+    @classmethod
+    def oldest(cls, column: str = "created_at") -> "QueryBuilder":
+        return cls.query().oldest(column)
+
+    @classmethod
+    def group_by(cls, column: str) -> "QueryBuilder":
+        return cls.query().group_by(column)
+
+    @classmethod
+    def group_by_raw(cls, expression: str) -> "QueryBuilder":
+        return cls.query().group_by_raw(expression)
+
+    @classmethod
+    def having(cls, column: str, equality: str, value) -> "QueryBuilder":
+        return cls.query().having(column, equality, value)
+
+    @classmethod
+    def between(cls, column: str, low, high) -> "QueryBuilder":
+        return cls.query().between(column, low, high)
+
+    @classmethod
+    def not_between(cls, column: str, low, high) -> "QueryBuilder":
+        return cls.query().not_between(column, low, high)
+
+    @classmethod
+    def distinct(cls) -> "QueryBuilder":
+        return cls.query().distinct()
+
+    @classmethod
+    def join(cls, table: str, column1: str, equality: str, column2: str, clause: str = "join") -> "QueryBuilder":
+        return cls.query().join(table, column1, equality, column2, clause)
+
+    @classmethod
+    def left_join(cls, table: str, column1: str, equality: str, column2: str) -> "QueryBuilder":
+        return cls.query().left_join(table, column1, equality, column2)
+
+    @classmethod
+    def right_join(cls, table: str, column1: str, equality: str, column2: str) -> "QueryBuilder":
+        return cls.query().right_join(table, column1, equality, column2)
+
+    @classmethod
+    def where_column(cls, column1: str, column2: str) -> "QueryBuilder":
+        return cls.query().where_column(column1, column2)
+
+    @classmethod
+    def when(cls, condition, callback) -> "QueryBuilder":
+        return cls.query().when(condition, callback)
+
+    @classmethod
+    def where_exists(cls, builder: "QueryBuilder") -> "QueryBuilder":
+        return cls.query().where_exists(builder)
+
+    @classmethod
+    def or_where_exists(cls, builder: "QueryBuilder") -> "QueryBuilder":
+        return cls.query().or_where_exists(builder)
+
     @classmethod
     def where_has(cls, relation: str, callback=None) -> "QueryBuilder":
         return cls.query().where_has(relation, callback)

{fastapi_startkit-0.28.0 → fastapi_startkit-0.29.0}/src/fastapi_startkit/providers/Provider.py

@@ -1,6 +1,6 @@
 from typing import TYPE_CHECKING
 
-from fastapi_startkit.helpers.string import Str
+from fastapi_startkit.support import Str
 
 from fastapi_startkit.helpers.dataclass import Dataclass
 

{fastapi_startkit-0.28.0 → fastapi_startkit-0.29.0}/src/fastapi_startkit/storage/drivers/local.py

@@ -5,7 +5,7 @@ from shutil import copyfile, move
 
 from ..filestream import FileStream
 from ..file import File
-from ...utils.filesystem import get_extension
+from ..helper import get_extension
 
 
 class LocalDriver:

{fastapi_startkit-0.28.0 → fastapi_startkit-0.29.0}/src/fastapi_startkit/storage/drivers/s3.py

@@ -2,7 +2,7 @@ import os
 import uuid
 
 from ..file import File
-from ...utils.filesystem import get_extension
+from ..helper import get_extension
 
 
 class S3Driver:

{fastapi_startkit-0.28.0 → fastapi_startkit-0.29.0}/src/fastapi_startkit/storage/file.py

@@ -1,6 +1,6 @@
 import hashlib
 
-from ..utils.filesystem import get_extension
+from .helper import get_extension
 
 
 class File:

{fastapi_startkit-0.28.0 → fastapi_startkit-0.29.0}/src/fastapi_startkit/storage/filestream.py

@@ -1,6 +1,6 @@
 import os
 
-from ..utils.filesystem import get_extension
+from .helper import get_extension
 
 
 class FileStream:

fastapi_startkit-0.29.0/src/fastapi_startkit/storage/helper.py

@@ -0,0 +1,33 @@
+import mimetypes
+import os
+import pathlib
+
+
+def get_module_dir(module_file):
+    return os.path.dirname(os.path.realpath(module_file))
+
+
+mimetypes.init([os.path.join(get_module_dir(__file__), "data/mime.types")])
+
+KNOWN_MIME_TYPES = mimetypes.types_map.keys()
+
+
+def get_extension(filepath: str, without_dot=False) -> str:
+    """Get a file extension from a filepath. If without_dot= True, the prefix will be removed from
+    the extension."""
+    extension_parts = pathlib.Path(filepath).suffixes
+    extension = ""
+    if extension_parts:
+        # try to join all the parts until only one part to check if it's a known extension
+        for i in range(len(extension_parts)):
+            try_extension = "".join(extension_parts[i:])
+            if try_extension in KNOWN_MIME_TYPES:
+                extension = try_extension
+                break
+        # if no known extension found, return the last part as the extension
+        if not extension:
+            extension = extension_parts[-1]
+
+        if without_dot:
+            extension = extension[1:]
+    return extension

fastapi_startkit-0.29.0/src/fastapi_startkit/support/__init__.py

@@ -0,0 +1,4 @@
+from .collection import Collection, collect
+from .string import Str, Stringable
+
+__all__ = ["Collection", "collect", "Str", "Stringable"]

{fastapi_startkit-0.28.0/src/fastapi_startkit/collection → fastapi_startkit-0.29.0/src/fastapi_startkit/support}/collection.py

@@ -555,7 +555,11 @@ class Collection:
             ">": operator.gt,
             ">=": operator.ge,
         }
-        return operators[op](str(a), str(b))
+        # Use numeric comparison when both values are numeric
+        try:
+            return operators[op](float(a), float(b))
+        except (TypeError, ValueError):
+            return operators[op](str(a), str(b))
 
     def __iter__(self):
         for item in self._items:
@@ -611,3 +615,8 @@ class Collection:
             items = items.all()
 
         return items
+
+
+def collect(items=None) -> Collection:
+    """Shortcut to wrap items in a Collection."""
+    return Collection(items or [])

fastapi_startkit-0.28.0/src/fastapi_startkit/collection/__init__.py

@@ -1 +0,0 @@
-from .collection import Collection

fastapi_startkit-0.28.0/src/fastapi_startkit/exceptions.backup/DD.py

@@ -1,38 +0,0 @@
-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-0.28.0/src/fastapi_startkit/exceptions.backup/ExceptionHandler.py

@@ -1,70 +0,0 @@
-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-0.28.0/src/fastapi_startkit/exceptions.backup/__init__.py

@@ -1,38 +0,0 @@
-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-0.28.0/src/fastapi_startkit/exceptions.backup/exceptionite/blocks.py

@@ -1,101 +0,0 @@
-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-0.28.0/src/fastapi_startkit/exceptions.backup/exceptionite/controllers.py

@@ -1,13 +0,0 @@
-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)