fastapi-mongo-base 0.8.30__py3-none-any.whl

fastapi_mongo_base/utils/imagetools.py

@@ -0,0 +1,261 @@
+import base64
+import itertools
+from fractions import Fraction
+from io import BytesIO
+from typing import Literal
+
+import httpx
+from aiocache import cached
+from PIL import Image
+
+
+def rgb_to_hex(rgb):
+    """Convert RGB color to HEX."""
+    r = min(255, max(0, rgb[0]))
+    g = min(255, max(0, rgb[1]))
+    b = min(255, max(0, rgb[2]))
+    return "#{:02x}{:02x}{:02x}".format(int(r), int(g), int(b))
+
+
+def rgb_to_xyz(rgb):
+    r, g, b = rgb
+
+    # Normalize the RGB values to the range [0, 1]
+    r = r / 255.0
+    g = g / 255.0
+    b = b / 255.0
+
+    # Apply the gamma correction (inverse of sRGB companding)
+    if r > 0.04045:
+        r = ((r + 0.055) / 1.055) ** 2.4
+    else:
+        r = r / 12.92
+
+    if g > 0.04045:
+        g = ((g + 0.055) / 1.055) ** 2.4
+    else:
+        g = g / 12.92
+
+    if b > 0.04045:
+        b = ((b + 0.055) / 1.055) ** 2.4
+    else:
+        b = b / 12.92
+
+    # Convert to XYZ using the RGB to XYZ matrix transformation
+    x = r * 0.4124564 + g * 0.3575761 + b * 0.1804375
+    y = r * 0.2126729 + g * 0.7151522 + b * 0.0721750
+    z = r * 0.0193339 + g * 0.1191920 + b * 0.9503041
+
+    return (x, y, z)
+
+
+def xyz_to_lab(xyz):
+    x, y, z = xyz
+
+    # Define the reference white point
+    x_ref = 0.95047
+    y_ref = 1.00000
+    z_ref = 1.08883
+
+    # Normalize the XYZ values by the reference white point
+    x = x / x_ref
+    y = y / y_ref
+    z = z / z_ref
+
+    # Apply the LAB transformation
+    def f(t):
+        if t > 0.008856:
+            return t ** (1 / 3)
+        else:
+            return (7.787 * t) + (16 / 116)
+
+    l = 116 * f(y) - 16
+    a = 500 * (f(x) - f(y))
+    b = 200 * (f(y) - f(z))
+
+    return (l, a, b)
+
+
+def rgb_to_lab(rgb):
+    xyz = rgb_to_xyz(rgb)
+    lab = xyz_to_lab(xyz)
+    return lab
+
+
+def add_watermark_to_image(
+    background_image_path: str | bytes | Image.Image,
+    watermark_image_path: str,
+    position: tuple[int, int] = (0, 0),
+    resize: tuple[int, int] = None,
+) -> Image:
+    """
+    Add an watermark image to a background image at a specified position using PIL.
+
+    :param background_image_path: Path to the background image.
+    :param watermark_image_path: Path to the watermark image.
+    :param position: A tuple (x, y) representing the position to place the watermark.
+    :param resize: A tuple (w, h) representing the target size of placed watermark.
+    :return: An Image object with the watermark added.
+    """
+
+    background = Image.open(background_image_path)
+    w, h = background.size
+    watermark = Image.open(watermark_image_path)
+
+    position = (w + position[0]) % w, (h + position[1]) % h
+
+    if resize:
+        watermark = watermark.resize((50, 50))
+
+    background.paste(watermark, position[0], position[1], watermark)
+
+    return background
+
+
+def get_aspect_ratio_str(width: int, height: int) -> str:
+    fr = Fraction(height, width)
+    return f"{fr.denominator}:{fr.numerator}"
+
+
+def resize_image(
+    image: Image.Image | BytesIO, new_width=384, new_height=None
+) -> Image.Image:
+    if isinstance(image, BytesIO):
+        image = Image.open(image)
+
+    if new_width is None and new_height is None:
+        return image
+
+    original_width, original_height = image.size
+    aspect_ratio = original_height / original_width
+
+    if new_height is None:
+        new_height = int(aspect_ratio * new_width)
+    elif new_width is None:
+        new_width = int(new_height / aspect_ratio)
+
+    resized_image = image.resize((new_width, new_height))
+    return resized_image
+
+
+def split_image(image: Image.Image, sections=(2, 2), **kwargs) -> list[Image.Image]:
+    parts = []
+    for i, j in itertools.product(range(sections[0]), range(sections[1])):
+        x = j * image.width // sections[0]
+        y = i * image.height // sections[1]
+        region = image.crop(
+            (x, y, x + image.width // sections[0], y + image.height // sections[1])
+        )
+        parts.append(region)
+    return parts
+
+
+def convert_image(
+    image: Image.Image, format: Literal["JPEG", "PNG", "WEBP", "BMP", "GIF"] = "JPEG"
+) -> Image.Image:
+    color_mode = "RGB" if format not in ("PNG", "WEBP") else "RGBA"
+    return image.convert(color_mode)
+
+
+def convert_image_bytes(
+    image: Image.Image,
+    format: Literal["JPEG", "PNG", "WEBP", "BMP", "GIF"] = "JPEG",
+    quality=None,
+) -> BytesIO:
+    image_bytes = BytesIO()
+    convert_image(image, format).save(
+        image_bytes,
+        format=format,
+        **{"quality": quality} if quality else {},
+    )
+    image_bytes.seek(0)
+    return image_bytes
+
+
+def strip_metadata(
+    image: Image.Image,
+    format: Literal["JPEG", "PNG", "WEBP", "BMP", "GIF"] = "JPEG",
+) -> Image.Image:
+    """Strip metadata from the image by re-creating it in memory."""
+    return convert_image(image, format)
+
+
+def image_to_base64(
+    image: Image.Image,
+    format: Literal["JPEG", "PNG", "WEBP", "BMP", "GIF"] = "JPEG",
+    quality: int = 90,
+    *,
+    include_base64_header: bool = True,
+    **kwargs,
+) -> str:
+    buffered = convert_image_bytes(image, format, quality)
+    base64_str = base64.b64encode(buffered.getvalue()).decode("utf-8")
+    if include_base64_header:
+        return f"data:image/{format};base64,{base64_str}"
+    return base64_str
+
+
+def load_from_base64(encoded: str) -> Image.Image:
+    """Load an image from a base64 encoded string."""
+    encoded = encoded.split(",")[1]
+    encoded += "=" * (4 - len(encoded) % 4)
+    buffered = BytesIO(base64.b64decode(encoded))
+    return Image.open(buffered)
+
+
+async def load_from_url(url: str) -> Image.Image:
+    """Load an image from a URL."""
+    async with httpx.AsyncClient() as client:
+        r = await client.get(url)
+        r.raise_for_status()
+    buffered = BytesIO(r.content)
+    return Image.open(buffered)
+
+
+def compress_image(image: Image.Image, max_size_kb: int) -> Image.Image:
+    """Compress image to fit within max_size_kb."""
+    while True:
+        buffered = BytesIO()
+        image.save(buffered, format="JPEG", optimize=True, quality=85)
+        encoded = base64.b64encode(buffered.getvalue()).decode()
+        if len(encoded) <= max_size_kb * 1024:
+            break
+        new_width = int(image.width * 4 / 5)
+        new_height = int(image.height * 4 / 5)
+        image = resize_image(image, new_width, new_height)
+    return image
+
+
+@cached(ttl=60 * 60 * 24)
+async def download_image(
+    url: str, max_width: int | None = None, max_size_kb: int | None = None, **kwargs
+) -> Image.Image:
+    """Fetch, resize, remove metadata, and compress an image to fit the specified constraints."""
+    # Load image from either base64 or URL
+    image = (
+        load_from_base64(url)
+        if url.startswith("data:image")
+        else await load_from_url(url)
+    )
+
+    # Prepare image (convert to RGB and strip metadata)
+    image = strip_metadata(image)
+
+    if max_size_kb is None and max_width is None:
+        return image
+
+    # Resize if needed
+    image = resize_image(image, max_width)
+
+    # Compress if needed
+    if max_size_kb is not None:
+        image = compress_image(image, max_size_kb)
+
+    return image
+
+
+async def download_image_base64(
+    url: str, max_width: int | None = None, max_size_kb: int | None = None, **kwargs
+) -> str:
+    image = await download_image(url, max_width, max_size_kb, **kwargs)
+    return image_to_base64(image, **kwargs)

fastapi_mongo_base/utils/texttools.py

@@ -0,0 +1,207 @@
+import random
+import re
+import string
+import unicodedata
+import uuid
+from urllib.parse import urlparse
+
+
+def backtick_formatter(text: str):
+    text = text.strip().strip("```json").strip("```").strip()
+    return text
+
+
+def format_string_keys(text: str) -> set[str]:
+    return {t[1] for t in string.Formatter().parse(text) if t[1]}
+
+
+def format_string_fixer(**kwargs):
+    list_length = len(next(iter(kwargs.values())))
+
+    # Initialize the target list
+    target = []
+
+    # Iterate over each index of the lists
+    for i in range(list_length):
+        # Create a new dictionary for each index
+        entry = {key: kwargs[key][i] for key in kwargs}
+        # Append the new dictionary to the target list
+        target.append(entry)
+
+    return target
+
+
+def escape_markdown(text: str):
+    replacements = [
+        ("_", r"\_"),
+        ("*", r"\*"),
+        ("[", r"\["),
+        ("]", r"\]"),
+        ("(", r"\("),
+        (")", r"\)"),
+        ("~", r"\~"),
+        # ("`", r"\`"),
+        (">", r"\>"),
+        ("#", r"\#"),
+        ("+", r"\+"),
+        ("-", r"\-"),
+        ("=", r"\="),
+        ("|", r"\|"),
+        ("{", r"\{"),
+        ("}", r"\}"),
+        (".", r"\."),
+        ("!", r"\!"),
+        ("=", r"\="),
+    ]
+
+    for old, new in replacements:
+        text = text.replace(old, new)
+
+    return text
+
+
+def split_text(text: str, max_chunk_size=4096):
+    # Split text into paragraphs
+    paragraphs = text.split("\n")
+    chunks = []
+    current_chunk = ""
+
+    for paragraph in paragraphs:
+        if len(current_chunk) + len(paragraph) + 1 > max_chunk_size:
+            if current_chunk:
+                if current_chunk.count("```") % 2 == 1:
+                    chunks.append(current_chunk[: current_chunk.rfind("```")].strip())
+                    current_chunk = current_chunk[current_chunk.rfind("```") :]
+                    continue
+
+                chunks.append(current_chunk.strip())
+                current_chunk = ""
+                continue
+
+        if len(paragraph) > max_chunk_size:
+            # Split paragraph into sentences
+            sentences = re.split(r"(?<=[.!?]) +", paragraph)
+            for sentence in sentences:
+                if len(current_chunk) + len(sentence) + 1 > max_chunk_size:
+                    if current_chunk:
+                        chunks.append(current_chunk.strip())
+                        current_chunk = ""
+                if len(sentence) > max_chunk_size:
+                    # Split sentence into words
+                    words = sentence.split(" ")
+                    for word in words:
+                        if len(current_chunk) + len(word) + 1 > max_chunk_size:
+                            if current_chunk:
+                                chunks.append(current_chunk.strip())
+                                current_chunk = ""
+                        current_chunk += word + " "
+                else:
+                    current_chunk += sentence + " "
+        else:
+            current_chunk += paragraph + "\n"
+    if current_chunk:
+        chunks.append(current_chunk.strip())
+
+    return chunks
+
+
+def replace_unicode_digits(match: re.Match) -> str:
+    char = match.group()
+    return unicodedata.digit(char)
+
+
+def convert_to_english_digits(input_str: str):
+    non_ascii_digit_pattern = re.compile(r"\d", re.UNICODE)
+    return non_ascii_digit_pattern.sub(replace_unicode_digits, input_str)
+
+
+regex = re.compile(
+    r"^(https?|ftp):\/\/"  # http:// or https:// or ftp://
+    r"(?"
+    r":(?:[A-Z0-9](?:[A-Z0-9-]{0,61}[A-Z0-9])?\.)+[A-Z]{2,6}\.?|"  # domain...
+    # r"localhost|"  # or localhost...
+    # r"\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}|"  # or IPv4...
+    # r"\[?[A-F0-9]*:[A-F0-9:]+\]?"  # or IPv6...
+    r")"
+    r"(?::\d+)?"  # optional port
+    r"(?:\/[-A-Z0-9+&@#\/%=~_|$]*)*$",
+    re.IGNORECASE,
+)
+phone_regex = re.compile(r"^[\+]?[(]?[0-9]{3}[)]?[-\s\.]?[0-9]{3}[-\s\.]?[0-9]{4,6}$")
+email_regex = re.compile(r"^[a-zA-Z\._]+@[a-zA-Z0-9\.-_]+\.[a-zA-Z]{2,}$")
+username_regex = re.compile(r"^[a-zA-Z_][a-zA-Z0-9_]{2,16}$")
+
+
+def is_valid_uuid(val):
+    try:
+        uuid.UUID(str(val))
+        return True
+    except ValueError:
+        return False
+
+
+def is_valid_url(url):
+    # Check if the URL matches the regex
+    if re.match(regex, url) is None:
+        return False
+
+    # Additional check using urllib.parse to ensure proper scheme and netloc
+    parsed_url = urlparse(url)
+    return all([parsed_url.scheme, parsed_url.netloc])
+
+
+def is_username(username):
+    return username_regex.search(username)
+
+
+def is_email(email):
+    return email_regex.search(email)
+
+
+def is_phone(phone):
+    return phone_regex.search(phone)
+
+
+def generate_random_chars(length=6, characters=string.ascii_letters + string.digits):
+    # Generate the random characters
+    return "".join(random.choices(characters, k=length))
+
+
+def replace_whitespace(match: re.Match) -> str:
+    if "\n" in match.group():
+        return "\n"
+    else:
+        return " "
+
+
+def remove_whitespace(text: str) -> str:
+    return re.sub(r"\s+", replace_whitespace, text)
+
+
+def sanitize_filename(
+    draft_name: str, max_length: int = 0, space_remover: bool = True
+) -> str:
+    # get filename from URL
+    if draft_name.startswith("http"):
+        url_parts = urlparse(draft_name)
+        draft_name = url_parts.path
+
+    # Remove path and extension
+    draft_name = draft_name.split("/")[-1].strip()
+    dotted_name = draft_name.split(".")
+    pure_name = ".".join(dotted_name[:-1] if len(dotted_name) > 1 else dotted_name)
+
+    # Remove invalid characters and replace spaces with underscores
+    # Valid characters: alphanumeric, underscores, and periods and spaces
+    sanitized = re.sub(r"[^a-zA-Z0-9_. ]", "", pure_name)
+
+    if max_length > 0:
+        position = pure_name.find(" ", max_length * 4 // 5)
+        if position > max_length * 6 // 5 or position == -1:
+            position = max_length
+        sanitized[:position]  # Limit to 100 characters
+
+    if space_remover:
+        sanitized = sanitized.replace(" ", "_")  # Replace spaces with underscores
+
+    return sanitized

fastapi_mongo_base-0.8.30.dist-info/LICENSE.txt

@@ -0,0 +1,19 @@
+Copyright (c) 2016 The Python Packaging Authority (PyPA)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

fastapi_mongo_base-0.8.30.dist-info/METADATA

@@ -0,0 +1,69 @@
+Metadata-Version: 2.2
+Name: fastapi-mongo-base
+Version: 0.8.30
+Summary: A simple boilerplate application, including models and schemas and abstract router, for FastAPI with MongoDB
+Author-email: Mahdi Kiani <mahdikiany@gmail.com>
+Maintainer-email: Mahdi Kiani <mahdikiany@gmail.com>
+License: Copyright (c) 2016 The Python Packaging Authority (PyPA)
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy of
+        this software and associated documentation files (the "Software"), to deal in
+        the Software without restriction, including without limitation the rights to
+        use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+        of the Software, and to permit persons to whom the Software is furnished to do
+        so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Homepage, https://github.com/mahdikiani/fastapi-mongo-base-app
+Project-URL: Bug Reports, https://github.com/mahdikiani/fastapi-mongo-base-app/issues
+Project-URL: Funding, https://github.com/mahdikiani/fastapi-mongo-base-app
+Project-URL: Say Thanks!, https://saythanks.io/to/mahdikiani
+Project-URL: Source, https://github.com/mahdikiani/fastapi-mongo-base-app
+Keywords: fastapi,mongodb,beanie
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3 :: Only
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: pydantic>=1.8.2
+Requires-Dist: requests>=2.26.0
+Requires-Dist: pyjwt[crypto]
+Requires-Dist: singleton_package
+Requires-Dist: fastapi>=0.65.0
+Requires-Dist: uvicorn[standard]>=0.13.0
+Provides-Extra: image
+Requires-Dist: Pillow>=9.0.0; extra == "image"
+Provides-Extra: test
+Requires-Dist: coverage; extra == "test"
+Provides-Extra: image-similarity
+Requires-Dist: numpy>=1.21.0; extra == "image-similarity"
+Requires-Dist: imagededup>=0.3.0; extra == "image-similarity"
+Provides-Extra: all
+Requires-Dist: Pillow>=9.0.0; extra == "all"
+Requires-Dist: numpy>=1.21.0; extra == "all"
+Requires-Dist: imagededup>=0.3.0; extra == "all"
+
+# Fastapi Mongo 
+
+## Contributing
+Contributions are welcome! See CONTRIBUTING.md for more details on how to get involved.
+
+## License
+Distributed under the MIT License. See LICENSE for more information.

fastapi_mongo_base-0.8.30.dist-info/RECORD

@@ -0,0 +1,25 @@
+fastapi_mongo_base/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fastapi_mongo_base/cached.py,sha256=VcmunUkKxpJyeIq_fcGJGcJ_kzTcqZH8SP9FOa9b52A,3799
+fastapi_mongo_base/handlers.py,sha256=-dckS-qetIs990VFItOMY0yWxMzMuP5PqHuMgQFeA3w,1006
+fastapi_mongo_base/models.py,sha256=pLem_-cKOAu208zycigTDGBUG4nnq__jwx_n_hd6nVQ,11330
+fastapi_mongo_base/routes.py,sha256=BbWglY01tP0kpXOW6FEA5ydtp7kcwUaMFJRakxIkpR4,9275
+fastapi_mongo_base/schemas.py,sha256=MUYxkA2WCCl5r1vz3nxGlKIbIMpfWkhmsBkKC-lf7gg,2741
+fastapi_mongo_base/tasks.py,sha256=yPMTc83I4hTZyAybzGIt-yYmUjt3ZarNQE5r73J1Mm4,9109
+fastapi_mongo_base/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fastapi_mongo_base/core/app_factory.py,sha256=GZVUlGCRrtR1YhlXvWzdlyiTsYeXGSg1GA5MQ3jMUqc,5306
+fastapi_mongo_base/core/config.py,sha256=oCd_WN9h9NVIlFikdUdgOA1UtNtA4LYPMswPaeGxDr8,2703
+fastapi_mongo_base/core/db.py,sha256=9Uvqi6goBuNSdTDTRmp2BCrklqFSHJx2zjc_GD9jzWQ,1235
+fastapi_mongo_base/core/enums.py,sha256=f9fzuC9TlO00NnvntMOrSjGuYj_qXWnIxheAYfanpFk,782
+fastapi_mongo_base/core/exceptions.py,sha256=gv6kaC62AVfTjIYsQ3tldSx_xcuKH0iKL6NH_jX6Pu8,2449
+fastapi_mongo_base/core/middlewares.py,sha256=3sJH3eR1GsSsmrAp-DpbreIGWdt3J83I4ErkK4v7sqw,797
+fastapi_mongo_base/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fastapi_mongo_base/utils/aionetwork.py,sha256=92OJcp0CC-N7ugxveHueIdkQzJVjpjYhd2SnfOAA40U,2705
+fastapi_mongo_base/utils/basic.py,sha256=R5gMPNFzWjFEaYQ_0T3LFFVhEEgd2q6pSv0Q1Tk303E,2543
+fastapi_mongo_base/utils/bsontools.py,sha256=GTFXxw_6QtNVyXH5G52Q2hifOrJ-0oC75SaSQ292PZY,657
+fastapi_mongo_base/utils/imagetools.py,sha256=fUP0JXkYDiPxR92sKglq8nOX-MG-lQynZqgUyG-gmEk,7296
+fastapi_mongo_base/utils/texttools.py,sha256=6Jr1tdxaoTpTuRIIImlsUDGpUAE7we--DRYN7yVuuP8,6068
+fastapi_mongo_base-0.8.30.dist-info/LICENSE.txt,sha256=ceC9ZJOV9H6CtQDcYmHOS46NA3dHJ_WD4J9blH513pc,1081
+fastapi_mongo_base-0.8.30.dist-info/METADATA,sha256=MxMe9SjuI9fb1q9tneSb-tz3oOLM2xJbonmZJWqEuGA,3317
+fastapi_mongo_base-0.8.30.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+fastapi_mongo_base-0.8.30.dist-info/top_level.txt,sha256=EyddBr2RKKxMM_0PqvIjU0aLiQL88J-QNTqkOUGRVMo,19
+fastapi_mongo_base-0.8.30.dist-info/RECORD,,

fastapi_mongo_base-0.8.30.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.8.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

fastapi_mongo_base-0.8.30.dist-info/top_level.txt

@@ -0,0 +1 @@
+fastapi_mongo_base