fastapi-startkit 0.1.0__py3-none-any.whl

fastapi_startkit/utils/filesystem.py

@@ -0,0 +1,100 @@
+import os
+import platform
+import pathlib
+import mimetypes
+
+
+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
+
+
+def file_exists(directory):
+    """Create a directory at the given path for a file if it does not exist"""
+    return os.path.exists(os.path.dirname(directory))
+
+
+def make_full_directory(directory):
+    """Create all directories to the given path if they do not exist"""
+    if not os.path.isfile(directory):
+        if not os.path.exists(directory):
+            # Create the path to the model if it does not exist
+            os.makedirs(directory)
+
+        return True
+
+    return False
+
+
+def creation_date(path_to_file):
+    """Try to get the date that a file was created, falling back to when it was
+    last modified if that isn't possible.
+    """
+    if platform.system() == "Windows":
+        return os.path.getctime(path_to_file)
+    else:
+        stat = os.stat(path_to_file)
+        try:
+            return stat.st_birthtime
+        except AttributeError:
+            # We're probably on Linux. No easy way to get creation dates here,
+            # so we'll settle for when its content was last modified.
+            return stat.st_mtime
+
+
+def modified_date(path_to_file):
+    if platform.system() == "Windows":
+        return os.path.getmtime(path_to_file)
+    else:
+        stat = os.stat(path_to_file)
+        try:
+            return stat.st_mtime
+        except AttributeError:
+            # We're probably on Linux. No easy way to get creation dates here,
+            # so we'll settle for when its content was last modified.
+            return 0
+
+
+def render_stub_file(stub_file, name):
+    """Read stub file, replace placeholders and return content."""
+    with open(stub_file, "r") as f:
+        content = f.read()
+        content = content.replace("__class__", name)
+    return content
+
+
+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 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/utils/http.py

@@ -0,0 +1,101 @@
+"""Helpers for working with HTTP."""
+
+
+HTTP_STATUS_CODES = {
+    100: "100 Continue",
+    101: "101 Switching Protocol",
+    102: "102 Processing",
+    103: "Early Hints",
+    200: "200 OK",
+    201: "201 Created",
+    202: "202 Accepted",
+    203: "203 Non-Authoritative Information",
+    204: "204 No Content",
+    205: "205 Reset Content",
+    206: "206 Partial Content",
+    207: "207 Multi-Status",
+    208: "208 Multi-Status",
+    226: "226 IM Used",
+    300: "300 Multiple Choice",
+    301: "301 Moved Permanently",
+    302: "302 Found",
+    303: "303 See Other",
+    304: "304 Not Modified",
+    307: "307 Temporary Redirect",
+    308: "308 Permanent Redirect",
+    400: "400 Bad Request",
+    401: "401 Unauthorized",
+    402: "402 Payment Required",
+    403: "403 Forbidden",
+    404: "404 Not Found",
+    405: "405 Method Not Allowed",
+    406: "406 Not Acceptable",
+    407: "407 Proxy Authentication Required",
+    408: "408 Request Timeout",
+    409: "409 Conflict",
+    410: "410 Gone",
+    411: "411 Length Required",
+    412: "412 Precondition Failed",
+    413: "413 Payload Too Large",
+    414: "414 URI Too Long",
+    415: "415 Unsupported Media Type",
+    416: "416 Requested Range Not Satisfiable",
+    417: "417 Expectation Failed",
+    418: "418 I'm a teapot",
+    421: "421 Misdirected Request",
+    422: "422 Unprocessable Entity",
+    423: "423 Locked",
+    424: "424 Failed Dependency",
+    425: "425 Too Early",
+    426: "426 Upgrade Required",
+    428: "428 Precondition Required",
+    429: "429 Too Many Requests",
+    431: "431 Request Header Fields Too Large",
+    451: "451 Unavailable For Legal Reasons",
+    500: "500 Internal Server Error",
+    501: "501 Not Implemented",
+    502: "502 Bad Gateway",
+    503: "503 Service Unavailable",
+    504: "504 Gateway Timeout",
+    505: "505 HTTP Version Not Supported",
+    506: "506 Variant Also Negotiates",
+    507: "507 Insufficient Storage",
+    508: "508 Loop Detected",
+    510: "510 Not Extended",
+    511: "511 Network Authentication Required",
+}
+
+
+def generate_wsgi(wsgi={}, path="/", query_string="", method="GET"):
+    """Generate the WSGI environment dictionary that we receive from a HTTP request."""
+    import io
+
+    data = {
+        "wsgi.version": (1, 0),
+        "wsgi.multithread": False,
+        "wsgi.multiprocess": True,
+        "wsgi.run_once": False,
+        "wsgi.input": io.BytesIO(),
+        "SERVER_SOFTWARE": "gunicorn/19.7.1",
+        "REQUEST_METHOD": method,
+        "QUERY_STRING": query_string,
+        "RAW_URI": path,
+        "SERVER_PROTOCOL": "HTTP/1.1",
+        "HTTP_HOST": "127.0.0.1:8000",
+        "HTTP_ACCEPT": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+        "HTTP_UPGRADE_INSECURE_REQUESTS": "1",
+        "HTTP_COOKIE": "",
+        "HTTP_USER_AGENT": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_2) AppleWebKit/604.4.7 (KHTML, like Gecko) Version/11.0.2 Safari/604.4.7",
+        "HTTP_ACCEPT_LANGUAGE": "en-us",
+        "HTTP_ACCEPT_ENCODING": "gzip, deflate",
+        "HTTP_CONNECTION": "keep-alive",
+        "wsgi.url_scheme": "http",
+        "REMOTE_ADDR": "127.0.0.1",
+        "REMOTE_PORT": "62241",
+        "SERVER_NAME": "127.0.0.1",
+        "SERVER_PORT": "8000",
+        "PATH_INFO": path,
+        "SCRIPT_NAME": "",
+    }
+    data.update(wsgi)
+    return data

fastapi_startkit/utils/location.py

@@ -0,0 +1,90 @@
+"""Helpers to resolve absolute paths to the different app resources using a configured
+location."""
+from os.path import join, abspath
+
+from .str import as_filepath
+
+
+def _build_path(location_key, relative_path, absolute):
+    from wsgi import application
+
+    relative_dir = join(as_filepath(application.make(location_key)), relative_path)
+    return abspath(relative_dir) if absolute else relative_dir
+
+
+def base_path(relative_path=""):
+    """Build the absolute path to the project root directory or build the absolute path to a
+    given file relative to the project root directory."""
+    return abspath(relative_path)
+
+
+def views_path(relative_path="", absolute=True):
+    """Build the absolute path to the project views directory or build the absolute path to a given
+    file relative to the project views directory.
+
+    The relative path can be returned instead by setting absolute=False."""
+    return _build_path("views.location", relative_path, absolute)
+
+
+def controllers_path(relative_path="", absolute=True):
+    """Build the absolute path to the project controllers directory or build the absolute path to a given
+    file relative to the project controllers directory.
+
+    The relative path can be returned instead by setting absolute=False."""
+    return _build_path("controllers.location", relative_path, absolute)
+
+
+def mailables_path(relative_path="", absolute=True):
+    """Build the absolute path to the project controllers directory or build the absolute path to a given
+    file relative to the project controllers directory.
+
+    The relative path can be returned instead by setting absolute=False."""
+    return _build_path("mailables.location", relative_path, absolute)
+
+
+def config_path(relative_path="", absolute=True):
+    """Build the absolute path to the project configuration directory or build the absolute path to a given
+    file relative to the project configuration directory.
+
+    The relative path can be returned instead by setting absolute=False."""
+    return _build_path("config.location", relative_path, absolute)
+
+
+def migrations_path(relative_path="", absolute=True):
+    """Build the absolute path to the project migrations directory or build the absolute path to a given
+    file relative to the project migrations directory.
+
+    The relative path can be returned instead by setting absolute=False."""
+    return _build_path("migrations.location", relative_path, absolute)
+
+
+def seeds_path(relative_path="", absolute=True):
+    """Build the absolute path to the project seeds directory or build the absolute path to a given
+    file relative to the project seeds directory.
+
+    The relative path can be returned instead by setting absolute=False."""
+    return _build_path("seeds.location", relative_path, absolute)
+
+
+def jobs_path(relative_path="", absolute=True):
+    """Build the absolute path to the project jobs directory or build the absolute path to a given
+    file relative to the project jobs directory.
+
+    The relative path can be returned instead by setting absolute=False."""
+    return _build_path("jobs.location", relative_path, absolute)
+
+
+def resources_path(relative_path="", absolute=True):
+    """Build the absolute path to the project resources directory or build the absolute path to a given
+    file relative to the project resources directory.
+
+    The relative path can be returned instead by setting absolute=False."""
+    return _build_path("resources.location", relative_path, absolute)
+
+
+def models_path(relative_path="", absolute=True):
+    """Build the absolute path to the project models directory or build the absolute path to a given
+    file relative to the project models directory.
+
+    The relative path can be returned instead by setting absolute=False."""
+    return _build_path("models.location", relative_path, absolute)

fastapi_startkit/utils/str.py

@@ -0,0 +1,120 @@
+"""String generators and helpers"""
+
+import random
+import string
+from urllib import parse
+from typing import Any
+
+
+def random_string(length=4):
+    """Generate a random string based on the given length.
+
+    Keyword Arguments:
+        length {int} -- The amount of the characters to generate (default: {4})
+
+    Returns:
+        string
+    """
+    return "".join(
+        random.choice(string.ascii_uppercase + string.digits) for _ in range(length)
+    )
+
+
+def modularize(file_path, suffix=".py"):
+    """Transforms a file path to a dotted path. On UNIX paths contains / and on Windows \\.
+
+    Keyword Arguments:
+        file_path {str} -- A file path such app/controllers
+
+    Returns:
+        value {str} -- a dotted path such as app.controllers
+    """
+    # if the file had the .py extension remove it as it's not needed for a module
+    return removesuffix(file_path.replace("/", ".").replace("\\", "."), suffix)
+
+
+def as_filepath(dotted_path):
+    """Inverse of modularize, transforms a dotted path to a file path (with /).
+
+    Keyword Arguments:
+        dotted_path {str} -- A dotted path such app.controllers
+
+    Returns:
+        value {str} -- a file path such as app/controllers
+    """
+    return dotted_path.replace(".", "/")
+
+
+def removeprefix(string, prefix):
+    """Implementation of str.removeprefix() function available for Python versions lower than 3.9."""
+    if string.startswith(prefix):
+        return string[len(prefix) :]
+    else:
+        return string
+
+
+def removesuffix(string, suffix):
+    """Implementation of str.removesuffix() function available for Python versions lower than 3.9."""
+    if suffix and string.endswith(suffix):
+        return string[: -len(suffix)]
+    else:
+        return string
+
+
+def match(string: str, ref_string: str) -> str:
+    """Check if a given string matches a reference string. Wildcard '*' can be used at start, end
+    or middle of the string."""
+    if ref_string.startswith("*"):
+        ref_string = ref_string.replace("*", "")
+        return string.endswith(ref_string)
+    elif ref_string.endswith("*"):
+        ref_string = ref_string.replace("*", "")
+        return string.startswith(ref_string)
+    elif "*" in ref_string:
+        split_search = ref_string.split("*")
+        return string.startswith(split_search[0]) and string.endswith(split_search[1])
+    else:
+        return ref_string == string
+
+
+def add_query_params(url: str, query_params: dict) -> str:
+    """Add query params dict to a given url (which can already contain some query parameters)."""
+    path_result = parse.urlsplit(url)
+
+    base_url = (
+        f"{path_result.scheme}://{path_result.hostname}" if path_result.hostname else ""
+    )
+    base_path = path_result.path
+
+    # parse existing query parameters if any
+    existing_query_params = dict(parse.parse_qsl(path_result.query))
+    all_query_params = {**existing_query_params, **query_params}
+
+    # add query parameters to url if any
+    if all_query_params:
+        base_path += "?" + parse.urlencode(all_query_params)
+
+    result_url = f"{base_url}{base_path}"
+
+    # add fragment if exists
+    if path_result.fragment:
+        result_url = f"{result_url}#{path_result.fragment}"
+
+    return result_url
+
+
+def get_controller_name(controller: "str|Any") -> str:
+    """Get a controller string name from a controller argument used in routes."""
+    # controller is a class or class.method
+    if hasattr(controller, "__qualname__"):
+        if "." in controller.__qualname__:
+            controller_str = controller.__qualname__.replace(".", "@")
+        else:
+            controller_str = f"{controller.__qualname__}@__call__"
+    # controller is an instance, so the method will automatically be __call__
+    elif not isinstance(controller, str):
+        controller_str = f"{controller.__class__.__qualname__}@__call__"
+    # controller is anything else: "Controller@method"
+    else:
+        controller_str = str(controller)
+    return controller_str

fastapi_startkit/utils/structures.py

@@ -0,0 +1,97 @@
+"""Helpers for multiple data structures"""
+
+import importlib
+from importlib.abc import Loader
+from dotty_dict import dotty
+
+from ..exceptions.exceptions import LoaderNotFound
+
+from .str import modularize
+
+
+def load(path, object_name=None, default=None, raise_exception=False):
+    """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, loads the module.
+
+    Arguments:
+        path {str} -- A file path or a dotted path of a Python module
+        object {str} -- The object name to load in this module (None)
+        default {str} -- The default value to return if object not found in module (None)
+    Returns:
+        {object} -- The value (or default) read in the module or the module if no object name
+    """
+    # modularize path if needed
+    module_path = modularize(path)
+    # module = pydoc.locate(dotted_path)
+    try:
+        module = importlib.import_module(module_path)
+    except Exception as e:
+        error_message = (
+            f"'{module_path}' not found OR error when importing this module: {str(e)}"
+        )
+        print("Warning: " + error_message)
+
+        if raise_exception:
+            raise LoaderNotFound(error_message)
+        return None
+
+    if object_name is None:
+        return module
+    else:
+        try:
+            return getattr(module, object_name)
+        except KeyError:
+            if raise_exception:
+                raise LoaderNotFound(f"{object_name} not found in {module_path}")
+            else:
+                return default
+
+
+def data(dictionary={}):
+    """Transform the given dictionary to be read/written with dot notation.
+
+    Arguments:
+        dictionary {dict} -- a dictionary structure
+
+    Returns:
+        {dict} -- A dot dictionary
+    """
+    return dotty(dictionary)
+
+
+def data_get(dictionary, key, default=None):
+    """Read dictionary value from key using nested notation.
+
+    Arguments:
+        dictionary {dict} -- a dictionary structure
+        key {str} -- the dotted (or not) key to look for
+        default {object} -- the default value to return if the key does not exist (None)
+
+    Returns:
+        value {object}
+    """
+    # dotty dict uses : instead of * for wildcards
+    dotty_key = key.replace("*", ":")
+    return data(dictionary).get(dotty_key, default)
+
+
+def data_set(dictionary, key, value, overwrite=True):
+    """Set dictionary value at key using nested notation. Values are overridden by default but
+    this behaviour can be changed by passing overwrite=False.
+    The dictionary is edited in place but is also returned.
+
+    Arguments:
+        dictionary {dict} -- a dictionary structure
+        key {str} -- the dotted (or not) key to set
+        value {object} -- the value to set at key
+        overwrite {bool} -- override the value if key exists in dictionary (True)
+
+    Returns:
+        dictionary {dict} -- the edited dictionary
+    """
+    if "*" in key:
+        raise ValueError("You cannot set values with wildcards *")
+    if not overwrite and data_get(dictionary, key):
+        return
+    data(dictionary)[key] = value
+    return dictionary

fastapi_startkit/utils/time.py

@@ -0,0 +1,58 @@
+"""Time related helpers"""
+import pendulum
+
+
+def cookie_expire_time(str_time):
+    """Take a string like 1 month or 5 minutes and returns a datetime formatted with cookie format.
+
+    Arguments:
+        str_time {string} -- Could be values like 1 second or 3 minutes
+
+    Returns:
+        str -- Cookie expiration time (Thu, 21 Oct 2021 07:28:00)
+    """
+    instance = parse_human_time(str_time)
+    return instance.format("ddd, DD MMM YYYY HH:mm:ss")
+
+
+def parse_human_time(str_time):
+    """Take a string like 1 month or 5 minutes and returns a pendulum instance.
+
+    Arguments:
+        str_time {string} -- Could be values like 1 second or 3 minutes
+
+    Returns:
+        pendulum -- Returns Pendulum instance
+    """
+    if str_time == "now":
+        return pendulum.now("GMT")
+
+    if str_time != "expired":
+        number = int(str_time.split(" ")[0])
+        length = str_time.split(" ")[1]
+
+        if length in ("second", "seconds"):
+            return pendulum.now("GMT").add(seconds=number)
+        elif length in ("minute", "minutes"):
+            return pendulum.now("GMT").add(minutes=number)
+        elif length in ("hour", "hours"):
+            return pendulum.now("GMT").add(hours=number)
+        elif length in ("day", "days"):
+            return pendulum.now("GMT").add(days=number)
+        elif length in ("week", "weeks"):
+            return pendulum.now("GMT").add(weeks=number)
+        elif length in ("month", "months"):
+            return pendulum.now("GMT").add(months=number)
+        elif length in ("year", "years"):
+            return pendulum.now("GMT").add(years=number)
+
+        return None
+    else:
+        return pendulum.now("GMT").subtract(years=20)
+
+
+def migration_timestamp():
+    """Return current time formatted for creating migration filenames.
+    Example: 2021_01_09_043202
+    """
+    return pendulum.now().format("YYYY_MM_DD_HHmmss")

fastapi_startkit-0.1.0.dist-info/METADATA

@@ -0,0 +1,13 @@
+Metadata-Version: 2.4
+Name: fastapi-startkit
+Version: 0.1.0
+Summary: Core Masonite components (Container, Config, Loader)
+Author: Bedram Tamang
+Author-email: tmgbedu@gmail.com
+Requires-Python: >=3.12,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: dotty-dict (>=1.3.1)
+Requires-Dist: fastapi[standard] (>=0.124.4,<0.125.0)

fastapi_startkit-0.1.0.dist-info/RECORD

@@ -0,0 +1,76 @@
+fastapi_startkit/__init__.py,sha256=ObTUylrPyR4uTL4oz6CJfgs0Mk73TxEjPiVVDfn8dDQ,64
+fastapi_startkit/application.py,sha256=WluaoQ7J18actW7N6y5Uf_7VR7oqj0WXXZG7KbvbRL8,1077
+fastapi_startkit/configuration/Configuration.py,sha256=XpvbFVMQsiNTxWoT0mxDOC8IQONDvZpH-GcMwLdasH8,2772
+fastapi_startkit/configuration/__init__.py,sha256=o9cbhMDID-lec6tqPHX8_2csC2eYZYP1Z5c3igzjeIQ,69
+fastapi_startkit/configuration/helpers.py,sha256=yfoP_7xCFw_6dRLQu82GzdEZMRm8P79q76HJRDSc6PA,98
+fastapi_startkit/configuration/providers/ConfigurationProvider.py,sha256=uW3tu7asNk1CzkfkrFHqb0rf1a-PwlZJs42yXujGQhI,372
+fastapi_startkit/configuration/providers/__init__.py,sha256=CBjuHUetZl0Wd7Jgp1Qg5mFjRAiIq8e_socQQccXlUc,57
+fastapi_startkit/container/__init__.py,sha256=zfF4wNDfI-_iFYISsQc_gUjoHKV6AaPlO4ljevEFAow,33
+fastapi_startkit/container/container.py,sha256=t664orgo2zC4aCJhMOlVB41GUmoOJWOdGMtbQlfb9FM,16946
+fastapi_startkit/environment/environment.py,sha256=HN4zxmTs9-gm-CwBa0sr418P7isPLnZTFH-j6iD1wgY,2634
+fastapi_startkit/exceptions/DD.py,sha256=WgBlhCalfx4eY7RGPrx5NTsnF4s8Jr30cCVht5d_q2U,1080
+fastapi_startkit/exceptions/ExceptionHandler.py,sha256=keGkPZY7BvCP1PMUpq8iC5WuzDtNC_FoHaFcYzIMzVw,2924
+fastapi_startkit/exceptions/__init__.py,sha256=TBJJYH1tmIurA239fxCmBPCrHsyTP0ZaBmn63BpaoOs,1098
+fastapi_startkit/exceptions/exceptionite/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fastapi_startkit/exceptions/exceptionite/blocks.py,sha256=SDIIBAykKvKrjOl9beeT6z3eqJMoVI06n1yl4XMz8zI,2793
+fastapi_startkit/exceptions/exceptionite/controllers.py,sha256=px_HUBpr9Ff09lEYq2wapbLncXzgS4P7i-z7w7UUQko,581
+fastapi_startkit/exceptions/exceptionite/solutions.py,sha256=7PS192xcysA0w2UZBs6cvb6zn8ONNbvbR8Me-chqx8c,2352
+fastapi_startkit/exceptions/exceptionite/tabs.py,sha256=iknhFIrK_51tveRURFS3wZ0_eT66R1mgGggsMPfteRI,445
+fastapi_startkit/exceptions/exceptions.py,sha256=HNO_ud_eCqQoOMM0m4yQ1XWWwx5N1pkyeZT03091K2o,3569
+fastapi_startkit/exceptions/handlers/DumpExceptionHandler.py,sha256=Dkzn9aX5vaSuBR0qvR5h8wQFVbUbLLquMkiud5Z7i0Y,3110
+fastapi_startkit/exceptions/handlers/HttpExceptionHandler.py,sha256=b80QI4FgFN5QaTqx5Rz7PcC8H6FHy6k8J7FgqO-DarE,1084
+fastapi_startkit/exceptions/handlers/ModelNotFoundHandler.py,sha256=MCJGkAa0_EJwU9WjJMVnbw-oLE_MAdMQ1A73LvObnz4,440
+fastapi_startkit/facades/Auth.py,sha256=yLOZFMvG1HKbvd0OKkSVUNTXflWQC_o45IvcJDaVlIc,76
+fastapi_startkit/facades/Auth.pyi,sha256=V3mv1CaW03hmLAa2hvxiB21dznVqlimImkXhxB1BshY,1142
+fastapi_startkit/facades/Broadcast.py,sha256=LuAe-MJg7jTalJ3pSs1Q_FJae-TGZfQq7rrnEGmr0qQ,86
+fastapi_startkit/facades/Cache.py,sha256=nCo_xCSHnBKz_pk8aiHGspjKypWrE6EGTQqXq62MWqI,78
+fastapi_startkit/facades/Config.py,sha256=Q-2HlviEXRmzVSJ35S-lfr4b4_SOxitxtoL0Hn_1WHo,80
+fastapi_startkit/facades/Config.pyi,sha256=1xIbzbhGrcLVjfDzSModminRoG_CjwPpdjMqIZU3FjQ,399
+fastapi_startkit/facades/Dump.py,sha256=rnHsG1ceW4p4FT6jNPSIlXCSZiWrf_IBMXdwV-wOFqM,78
+fastapi_startkit/facades/Dump.pyi,sha256=MdEIxM3UYlz5-DExdiN0cUu6kOwqvcz8Vkvgvmia92c,936
+fastapi_startkit/facades/Facade.py,sha256=rSpVuH4ehojA9OjSv7q8rYPvQtVOFYN5fUDBSVXtDVQ,175
+fastapi_startkit/facades/Gate.py,sha256=6cJZMHRH1z95As5-svvwTSFm9ZeEJfWKKnLkrA7muXM,76
+fastapi_startkit/facades/Gate.pyi,sha256=ACKCDXW_x2eJ0IDHnlLL-QJAu8eQOJ2seph2Bv5IKgk,1382
+fastapi_startkit/facades/Hash.py,sha256=kMOa5ydml2wMyfeCiRckDn9j0CqNxR6GtShvSVmpNjE,76
+fastapi_startkit/facades/Hash.pyi,sha256=zfIzKSX-OXl-WFEXhAuDJTBitf-yIyS7AcQb8YBeXgU,1121
+fastapi_startkit/facades/Loader.py,sha256=zGpoa0rfpQySGYG6kCkGlDIqYAeqKV9p0W_Up3qperQ,80
+fastapi_startkit/facades/Loader.pyi,sha256=5va6whUqnFGRvtW13o-LCfLl5lJWvu7S3eWqqh2qoU4,1289
+fastapi_startkit/facades/Mail.py,sha256=VePnQMH3tCC-C6x2MzrAmJ9yuKmAq6jf0HExoC9ALN4,76
+fastapi_startkit/facades/Mail.pyi,sha256=HLjPw5cdnQnTxrEr2beEyfjNynUXAI7jia_V-9PX1nU,430
+fastapi_startkit/facades/Notification.py,sha256=GgnFpoP_ZVqxQbLMYGqROlKBKSelGMpNh4HSQ1KlgqE,92
+fastapi_startkit/facades/Notification.pyi,sha256=YCKT3oV6jdUDIQvvdJdCfZWQQLwzUSgbrnA6KjgeMjk,902
+fastapi_startkit/facades/Queue.py,sha256=zCARcIhbRSPOASPjNl3Y-sT30ZomnpKO65nxhcK4hlc,78
+fastapi_startkit/facades/Queue.pyi,sha256=5j6KhiO04h9yxobzo27CbZuvX3OU7Bq6vllnjMUirFc,364
+fastapi_startkit/facades/RateLimiter.py,sha256=-85JDDz1aBQ3tzUvMNQvSTJ91sASGJM8bXmO9KpYsd0,83
+fastapi_startkit/facades/RateLimiter.pyi,sha256=65KACncDSR-13NTxMtJwmFAJ7qMZ9T8eBUaSNm2UUcY,1770
+fastapi_startkit/facades/Request.py,sha256=dW1LMWAhCwoqGhOiLBgXqAhZHzd868neqcBcabZsE30,82
+fastapi_startkit/facades/Request.pyi,sha256=ecQ1K49JAtcHbc5kp0LhORzOfu1KXkpfxPiCu3TCEPM,3472
+fastapi_startkit/facades/Response.py,sha256=WeFinS3pADucCOCrbUQpmGIs5lTH0Yiq_5UnWq4YAVU,84
+fastapi_startkit/facades/Response.pyi,sha256=ROUaSHWzyVjdTa6-CZ8vJc_zKDxdl9t2O-U9LmirUm8,2630
+fastapi_startkit/facades/Session.py,sha256=2A4bEOJLeuctUhol0xawQWffvr_71B0AbyA-j6430ls,82
+fastapi_startkit/facades/Session.pyi,sha256=3oLikb3epJB775_dhIuqt7Vrqa7yIAYLTujKcqAzYnE,2056
+fastapi_startkit/facades/Storage.py,sha256=iMdvlfA5fPT6lJhBYdlzuisHGM8E26nWpqm4RhB1GU8,82
+fastapi_startkit/facades/Storage.pyi,sha256=3U_hPjHI9dvf1CG0NbgvnepolzUkhJwaqDEpv3ep8hQ,409
+fastapi_startkit/facades/Url.py,sha256=j_y_DdLw08xPFt9Fn09V2H9SAKRDyR9s43QWxAR51sg,74
+fastapi_startkit/facades/Url.pyi,sha256=QKgjH6wfqEEdsyLO2mMHUhOBhWcC9kmaOSr0PKnQ5jg,960
+fastapi_startkit/facades/View.py,sha256=J9gB1VTByvfzSFFB9H7Ppvg7Tej_9uo1VHJHQa70dUs,76
+fastapi_startkit/facades/View.pyi,sha256=Pp9ml6h9hoNnEFJjtxW0w2w_Nsc9TQ5DGK1XEO29Gis,2158
+fastapi_startkit/facades/__init__.py,sha256=yj_dPGoCipuFRrxW-lgl_NhnzdN4ZdS9PN2yxW4htm0,517
+fastapi_startkit/loader/Loader.py,sha256=5rYY3oURkNSiyfypfjGiJg-8HagflPQVHXoVayJWmhU,3131
+fastapi_startkit/loader/__init__.py,sha256=GWjMnz8OzbJJL2x_DaoaeNzZ-ESYQNeyLnYLAl4psxE,27
+fastapi_startkit/providers/ConfigurationProvider.py,sha256=MSt-AV28skbNY_iESL8r8zQbpufdlyriHrL95wUFbDo,422
+fastapi_startkit/providers/Provider.py,sha256=o1pVTzEl516Kx0qe30K67phpUR6ygDdGHRKklyI3-iI,279
+fastapi_startkit/providers/__init__.py,sha256=j78PJlEuaeaEO4xCsfNDPrWnHqOnwc2plbHMzKJG7_I,137
+fastapi_startkit/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fastapi_startkit/utils/collections.py,sha256=QBXCcNpoowY9JSrccDZ6YArxAhZHUxBxA7WxguVA-rM,14697
+fastapi_startkit/utils/console.py,sha256=KeFNVeFWmi_OaRVOC1PTbuBM5kWmv_twmDXWrK0lYtU,1054
+fastapi_startkit/utils/data/mime.types,sha256=YxY5l5GdijuD3RsffyPpEkzV-GYJmMN02kLGQbiGX1k,61134
+fastapi_startkit/utils/filesystem.py,sha256=UnEFo8r4gR09OcriVaGh5cDScC5jpxAlg0rnrZ-3BNE,3165
+fastapi_startkit/utils/http.py,sha256=AKfDx-8aY_YQh-ERHN97bpG-qUdwzN7gAsQphfGjEU0,3323
+fastapi_startkit/utils/location.py,sha256=xh6KWfPCYrhkZEr0s6zrn-3NgyOO0Tf1HOUdiZDMTVU,3817
+fastapi_startkit/utils/str.py,sha256=8_WsHSaOKkWA4GuQUaiOzROYihGkIdXZs_txYi79ro0,3958
+fastapi_startkit/utils/structures.py,sha256=VwRIcsNR1PhdUBtSzmwqxgXvBedKHOHV6T901_ZKOfY,3142
+fastapi_startkit/utils/time.py,sha256=ItbzAowY5MyTBQX6bMvgDh1WciR61ldTYyUPmKq1SSs,1882
+fastapi_startkit-0.1.0.dist-info/METADATA,sha256=kKNsod_LvvMmvQR_e3rsxa0Cu1xZhiLBNSWejoYPiU0,496
+fastapi_startkit-0.1.0.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+fastapi_startkit-0.1.0.dist-info/RECORD,,

fastapi_startkit-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 2.2.1
+Root-Is-Purelib: true
+Tag: py3-none-any