bootgraph 1.2.0__tar.gz

bootgraph-1.2.0/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2023 Matheus Doreto
+
+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.

bootgraph-1.2.0/PKG-INFO

@@ -0,0 +1,120 @@
+Metadata-Version: 2.1
+Name: bootgraph
+Version: 1.2.0
+Summary: A Python library for integrating SQLModel and Strawberry, providing a seamless GraphQL integration with FastAPI and advanced features for database interactions.
+Home-page: https://github.com/MDoreto/graphemy
+License: MIT
+Author: Matheus Doreto
+Author-email: matheusdoreto.md@gmail.com
+Requires-Python: >=3.12,<4.0
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Framework :: FastAPI
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Natural Language :: English
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Database
+Classifier: Topic :: Database :: Database Engines/Servers
+Requires-Dist: black (>=24.8.0,<25.0.0)
+Requires-Dist: fastapi (>=0.114.0,<0.115.0)
+Requires-Dist: sqlmodel (>=0.0.22,<0.0.23)
+Requires-Dist: strawberry-graphql[debug-server] (>=0.240.0,<0.241.0)
+Project-URL: Bug Tracker, https://github.com/MDoreto/graphemy/issues
+Project-URL: Documentation, https://graphemy.readthedocs.io/en/latest/
+Project-URL: Repository, https://github.com/MDoreto/graphemy
+Description-Content-Type: text/markdown
+
+
+<p align="center">
+  <img src="./docs/assets/logo.png" />
+</p>
+
+# GRAPHEMY
+<p align="center">
+    <em>Integrating SQLModel and Strawberry, providing a seamless GraphQL integration with Databases easy and fast.</em>
+</p>
+
+[![Documentation Status](https://readthedocs.org/projects/graphemy/badge/?version=latest)](https://graphemy.readthedocs.io/en/latest/?badge=latest)
+[![codecov](https://codecov.io/gh/MDoreto/graphemy/graph/badge.svg?token=GJDMVBA425)](https://codecov.io/gh/MDoreto/graphemy)
+![CI](https://github.com/MDoreto/graphemy/actions/workflows/pipeline.yml/badge.svg)
+<a href="https://pypi.org/project/graphemy" target="_blank">
+    <img src="https://img.shields.io/pypi/v/graphemy?color=%2334D058&label=pypi%20package" alt="Package version">
+</a>
+
+
+---
+
+**Documentation**: <a href="https://graphemy.readthedocs.io" target="_blank">https://graphemy.readthedocs.io</a>
+
+**Source Code**: <a href="https://github.com/MDoreto/graphemy" target="_blank">https://github.com/MDoreto/graphemy</a>
+
+---
+
+
+## Overview
+
+The Graphemy is designed to simplify and streamline the integration of SQLModel and Strawberry in Python projects. This library allows you to create a single class model, which, once declared, automatically provides GraphQL queries via Strawberry. These queries can be easily integrated into a FastAPI backend. All generated routes include filters on all fields, including a custom date filter. Additionally, it facilitates the creation of mutations for data modification and deletion by simply setting a variable in the model. The library also handles table relationships efficiently using Strawberry's dataloaders, providing a significant performance boost. Moreover, it offers a pre-configured authentication setup, which can be configured with just two functions.
+
+## Features
+
+- Integration of SQLModel and Strawberry for GraphQL support.
+- Automatic generation of GraphQL queries for FastAPI.
+- Powerful filtering capabilities, including custom date filters.
+- Effortless creation of mutations for data manipulation.
+- Efficient handling of table relationships using Strawberry's dataloaders.
+- Pre-configured authentication setup for easy configuration.
+
+## Prerequisites
+
+Before you begin using Graphemy, it is highly recommended that you have some prior knowledge of the essential libraries upon which this project is built. This will help you make the most of the features and carry out integrations more effectively. Please make sure you are familiar with the following libraries:
+
+**FastAPI**: A modern framework for building fast web APIs with Python. If you are not already familiar with FastAPI, you can refer to the [FastAPI documentation](https://fastapi.tiangolo.com/).
+
+**SQLModel**: An object-relational mapping (ORM) library for Python that simplifies and streamlines database interactions. To learn more about SQLModel, visit the [SQLModel documentation](https://sqlmodel.tiangolo.com/).
+
+**Strawberry**: A Python library for declaratively creating GraphQL schemas. For in-depth information on using Strawberry, access the [Strawberry documentation](https://strawberry.rocks/).
+
+Having a solid understanding of these libraries is crucial to making the most of Graphemy and effortlessly creating GraphQL APIs.
+
+## Create a Project
+
+I recomend you use Poetry, but you can use the enviroment manager that you want. So if you are using poetry, start the project:
+
+```bash
+# Create poetry project
+poetry new graphemy tutorial
+
+# Start Environment 
+poetry shell
+```
+
+You can also use the environment manager wanted, such as virtualenv
+
+```bash
+# Create a directory for tutorial
+mkdir graphemy-tutorial
+
+# Enter into that directory
+cd graphemy
+
+# Create virtual environment
+python -m venv venv
+
+#Start Environment
+venv/Scripts/Activate
+```
+
+## Requirements
+
+Now install Graphemy :) 
+```bash
+poetry add graphemy
+```
+Or using default python env with pip:
+
+```bash
+pip install graphemy
+```
+

bootgraph-1.2.0/README.md

@@ -0,0 +1,91 @@
+
+<p align="center">
+  <img src="./docs/assets/logo.png" />
+</p>
+
+# GRAPHEMY
+<p align="center">
+    <em>Integrating SQLModel and Strawberry, providing a seamless GraphQL integration with Databases easy and fast.</em>
+</p>
+
+[![Documentation Status](https://readthedocs.org/projects/graphemy/badge/?version=latest)](https://graphemy.readthedocs.io/en/latest/?badge=latest)
+[![codecov](https://codecov.io/gh/MDoreto/graphemy/graph/badge.svg?token=GJDMVBA425)](https://codecov.io/gh/MDoreto/graphemy)
+![CI](https://github.com/MDoreto/graphemy/actions/workflows/pipeline.yml/badge.svg)
+<a href="https://pypi.org/project/graphemy" target="_blank">
+    <img src="https://img.shields.io/pypi/v/graphemy?color=%2334D058&label=pypi%20package" alt="Package version">
+</a>
+
+
+---
+
+**Documentation**: <a href="https://graphemy.readthedocs.io" target="_blank">https://graphemy.readthedocs.io</a>
+
+**Source Code**: <a href="https://github.com/MDoreto/graphemy" target="_blank">https://github.com/MDoreto/graphemy</a>
+
+---
+
+
+## Overview
+
+The Graphemy is designed to simplify and streamline the integration of SQLModel and Strawberry in Python projects. This library allows you to create a single class model, which, once declared, automatically provides GraphQL queries via Strawberry. These queries can be easily integrated into a FastAPI backend. All generated routes include filters on all fields, including a custom date filter. Additionally, it facilitates the creation of mutations for data modification and deletion by simply setting a variable in the model. The library also handles table relationships efficiently using Strawberry's dataloaders, providing a significant performance boost. Moreover, it offers a pre-configured authentication setup, which can be configured with just two functions.
+
+## Features
+
+- Integration of SQLModel and Strawberry for GraphQL support.
+- Automatic generation of GraphQL queries for FastAPI.
+- Powerful filtering capabilities, including custom date filters.
+- Effortless creation of mutations for data manipulation.
+- Efficient handling of table relationships using Strawberry's dataloaders.
+- Pre-configured authentication setup for easy configuration.
+
+## Prerequisites
+
+Before you begin using Graphemy, it is highly recommended that you have some prior knowledge of the essential libraries upon which this project is built. This will help you make the most of the features and carry out integrations more effectively. Please make sure you are familiar with the following libraries:
+
+**FastAPI**: A modern framework for building fast web APIs with Python. If you are not already familiar with FastAPI, you can refer to the [FastAPI documentation](https://fastapi.tiangolo.com/).
+
+**SQLModel**: An object-relational mapping (ORM) library for Python that simplifies and streamlines database interactions. To learn more about SQLModel, visit the [SQLModel documentation](https://sqlmodel.tiangolo.com/).
+
+**Strawberry**: A Python library for declaratively creating GraphQL schemas. For in-depth information on using Strawberry, access the [Strawberry documentation](https://strawberry.rocks/).
+
+Having a solid understanding of these libraries is crucial to making the most of Graphemy and effortlessly creating GraphQL APIs.
+
+## Create a Project
+
+I recomend you use Poetry, but you can use the enviroment manager that you want. So if you are using poetry, start the project:
+
+```bash
+# Create poetry project
+poetry new graphemy tutorial
+
+# Start Environment 
+poetry shell
+```
+
+You can also use the environment manager wanted, such as virtualenv
+
+```bash
+# Create a directory for tutorial
+mkdir graphemy-tutorial
+
+# Enter into that directory
+cd graphemy
+
+# Create virtual environment
+python -m venv venv
+
+#Start Environment
+venv/Scripts/Activate
+```
+
+## Requirements
+
+Now install Graphemy :) 
+```bash
+poetry add graphemy
+```
+Or using default python env with pip:
+
+```bash
+pip install graphemy
+```

bootgraph-1.2.0/graphemy/__init__.py

@@ -0,0 +1,31 @@
+import os
+
+from sqlmodel import Field
+
+from graphemy.dl import Dl
+from graphemy.models import Graphemy
+from graphemy.router import GraphemyRouter
+from graphemy.setup import Setup
+
+
+def import_files(path):
+    """
+    Recursively imports all Python files found in the specified directory and its subdirectories,
+    excluding `__init__.py`. This function is intended to facilitate the dynamic loading of modules,
+    particularly useful in scenarios like automatic model discovery in web applications.
+
+    Args:
+        path (str): The directory path from which Python files should be imported.
+
+    Note:
+        - This function modifies the global namespace by dynamically importing modules.
+        - Import paths are adjusted to be relative, considering the package structure.
+    """
+    for root, dirs, files in os.walk(path):
+        for file in files:
+            if file.endswith(".py") and file != "__init__.py":
+                module_name = os.path.splitext(file)[0]
+                module_path = os.path.join(root, module_name)
+                module_path_rel = os.path.relpath(os.path.join(root, module_name))
+                module_path = module_path_rel.replace(os.path.sep, ".")
+                exec(f"import {module_path}")

bootgraph-1.2.0/graphemy/database/operations.py

@@ -0,0 +1,154 @@
+from typing import TYPE_CHECKING
+
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.orm import sessionmaker
+from sqlmodel import Session, and_, extract, or_, select
+
+from ..schemas.models import DateFilter
+from ..setup import Setup
+from .utils import get_filter, get_keys
+
+if TYPE_CHECKING:
+    from ..models import Graphemy
+
+
+async def get_items(
+    model: "Graphemy",
+    parameters: list[tuple],
+    id: str | list[str] = "id",
+    many: bool = True,
+):
+    groups = {}
+    id_groups = {}
+    filters = {}
+    params = {}
+    for p in parameters:
+        f = p[0]
+        if not f in filters:
+            filters[f] = []
+        filters[f].append(p[1][1])
+        groups[p] = [] if many else None
+        if not p[1][1] in id_groups:
+            id_groups[p[1][1]] = []
+        id_groups[p[1][1]].append(p)
+    query = select(model)
+    query_filters = []
+    for i, f in enumerate(filters):
+        if f[1]:
+            filter_temp = []
+            for k, v in f[1]:
+                if v:
+                    if isinstance(v[0], tuple):
+                        if v[2][1]:
+                            filter_temp.append(
+                                extract("year", getattr(model, k)) == v[2][1]
+                            )
+                        if v[0][1]:
+                            filter_temp.append(getattr(model, k).in_(list(v[0][1])))
+                        if v[1][1] and v[1][1][0]:
+                            filter_temp.append(getattr(model, k) >= v[1][1][0])
+                        if v[1][1] and v[1][1][1]:
+                            filter_temp.append(getattr(model, k) <= v[1][1][1])
+                    else:
+                        filter_temp.append(getattr(model, k).in_(v))
+        else:
+            filter_temp = [True]
+
+        query_filters.append(
+            and_(*filter_temp, get_filter(model, filters[f], id, params, i))
+        )
+    results = await Setup.execute_query(
+        query.where(or_(*query_filters)).params(**params), model.__enginename__
+    )
+    for r in results:
+        temp = id_groups[get_keys(r, id)]
+
+        if len(temp) == 1:
+            key = temp[0]
+            if many:
+                groups[key].append(r)
+            else:
+                groups[key] = r
+        else:
+            for t in temp:
+                if not t[0][1] or all([getattr(r, k) in v for k, v in t[0][1] if v]):
+                    if many:
+                        groups[t].append(r)
+                    else:
+                        groups[t] = r
+    return groups.values()
+
+
+async def get_all(model: "Graphemy", filters, query_filter) -> list:
+    query = select(model).where(query_filter)
+    if filters:
+        filters = vars(filters)
+        for k, v in filters.items():
+            if isinstance(v, DateFilter):
+                if v.year:
+                    query = query.where(extract("year", getattr(model, k)) == v.year)
+                if v.items:
+                    query = query.where(getattr(model, k).in_(v.items))
+                if v.range and v.range[0]:
+                    query = query.where(getattr(model, k) >= (v.range[0]))
+                if v.range and v.range[1]:
+                    query = query.where(getattr(model, k) <= (v.range[1]))
+            elif filters[k]:
+                query = query.where(getattr(model, k).in_(filters[k]))
+    r = await Setup.execute_query(query, model.__enginename__)
+    return r
+
+
+async def put_item(model: "Graphemy", item, id="id"):
+    id = [getattr(item, i) for i in id]
+    kwargs = vars(item)
+    engine = Setup.engine[model.__enginename__]
+    if Setup.async_engine:
+        async_session = sessionmaker(
+            engine, class_=AsyncSession, expire_on_commit=False
+        )
+        async with async_session() as session:
+            if not id or None in id:
+                new_item = model(**kwargs)
+            else:
+                new_item = await session.get(model, id)
+                if not new_item:
+                    new_item = model(**kwargs)
+                for key, value in kwargs.items():
+                    setattr(new_item, key, value)
+            session.add(new_item)
+            await session.commit()
+            await session.refresh(new_item)
+    else:
+        with Session(engine) as session:
+            if not id or None in id:
+                new_item = model(**kwargs)
+            else:
+                new_item = session.get(model, id)
+                if not new_item:
+                    new_item = model(**kwargs)
+                for key, value in kwargs.items():
+                    setattr(new_item, key, value)
+            session.add(new_item)
+            session.commit()
+            session.refresh(new_item)
+    return new_item
+
+
+async def delete_item(model: "Graphemy", item, id="id"):
+    id = [getattr(item, i) for i in id]
+    engine = Setup.engine[model.__enginename__]
+    if Setup.async_engine:
+        async_session = sessionmaker(
+            engine, class_=AsyncSession, expire_on_commit=False
+        )
+        async with async_session() as session:
+            item = await session.get(model, id)
+            await session.delete(item)
+            await session.commit()
+    else:
+        with Session(engine) as session:
+            item = session.get(model, id)
+            session.delete(item)
+            session.commit()
+    return item

bootgraph-1.2.0/graphemy/database/utils.py

@@ -0,0 +1,57 @@
+from datetime import date
+from typing import TYPE_CHECKING
+
+from sqlalchemy.sql.elements import BinaryExpression
+from sqlmodel import and_, bindparam, or_
+
+if TYPE_CHECKING:
+    from ..models import Graphemy
+
+
+def get_keys(model: "Graphemy", id: str | list[str]) -> tuple | str:
+    if isinstance(id, list):
+        return tuple([getattr(model, id[i]) for i in range(len(id))])
+    value = getattr(model, id)
+    if isinstance(value, str):
+        value = value.strip()
+    return value
+
+
+def get_filter(
+    model: "Graphemy",
+    keys: tuple,
+    id: str | list[str],
+    params: dict,
+    i: int,
+) -> BinaryExpression:
+    if isinstance(id, list):
+        filter = []
+        for j, key in enumerate(keys):
+            f = []
+            if None not in key:
+                for k in range(len(id)):
+                    f.append(
+                        id[k]
+                        if type(id[k]) == int
+                        else (
+                            id[k][1:]
+                            if id[k].startswith("_")
+                            else getattr(model, id[k])
+                            == bindparam(
+                                f"p{i}_{j}_{k}",
+                                literal_execute=not isinstance(key[k], date),
+                            )
+                        )
+                    )
+                    params[f"p{i}_{j}_{k}"] = key[k]
+                filter.append(and_(*f))
+            else:
+                filter.append(False)
+        return or_(*filter)
+    elif None in keys:
+        keys.remove(None)
+    params[f"p{i}"] = keys
+    a = getattr(model, id).in_(bindparam(f"p{i}", expanding=True, literal_execute=True))
+    return getattr(model, id).in_(
+        bindparam(f"p{i}", expanding=True, literal_execute=True)
+    )

bootgraph-1.2.0/graphemy/dl.py

@@ -0,0 +1,164 @@
+from typing import Type
+
+from strawberry.dataloader import DataLoader
+
+# from . import Graphemy
+from .schemas.models import DateFilter
+
+
+class CustomResolver:
+    def __init__(self, resolver_func):
+        self.resolver_func = resolver_func
+
+class ManyRelation:
+    def __init__(
+            self,
+            response_class: Type["Graphemy"],
+            relation_class: Type["Graphemy"],
+            source: str | list[str],
+            source_relation: str | list[str],
+            target: str | list[str],
+            target_relation: str | list[str],
+            foreign_key: bool = None,
+    ):
+        if type(source) != type(source_relation):
+            raise "source and source_relation must have same type"
+        if type(target) != type(target_relation):
+            raise "target and target_relation must have same type"
+        if type(source) == list:
+            if len(source) != len(source_relation):
+                raise "source and source_relation must have same length"
+            ids = {}
+            for i, id in enumerate(source_relation):
+                ids[id] = source[i]
+            source_relation.sort()
+            source = [ids[id] for id in source_relation]
+        if type(target) == list:
+            if len(target) != len(target_relation):
+                raise "target and target_relation must have same length"
+            ids = {}
+            for i, id in enumerate(target_relation):
+                ids[id] = source[i]
+            target_relation.sort()
+            target = [ids[id] for id in target_relation]
+        self.source = source
+        self.source_relation = source_relation
+        self.foreign_key = foreign_key
+        self.response_class = response_class
+        self.relation_class = relation_class
+        self.target = target
+        self.target_relation = target_relation
+        # There might be checks that relation_class has target and response_class has source
+
+
+class Dl:
+    """
+    A utility class designed to facilitate the linking of source and target fields
+    across different models. This is particularly useful for setting up data loaders
+    where fields from one model may depend on fields in another, and if foreign keys should be created based on relationships.
+
+    Attributes:
+        source (str | list[str]): The source field(s) from where data is to be fetched.
+        target (str | list[str]): The target field(s) where data is to be deposited.
+        foreign_key (bool): Indicates whether the relationship should create a foreign key
+            (default is False).
+
+    Raises:
+        ValueError: If the types of source and target do not match, or if they are lists
+            and do not have the same length.
+    """
+
+    source: str | list[str]
+    target: str | list[str]
+    foreign_key: bool | None = None
+
+    def __init__(
+        self,
+        source: str | list[str],
+        target: str | list[str],
+        foreign_key: bool = None,
+    ):
+        if type(source) != type(target):
+            raise "source and target must have same type"
+        if type(source) == list:
+            if len(source) != len(target):
+                raise "source and target must have same length"
+            ids = {}
+            for i, id in enumerate(target):
+                ids[id] = source[i]
+            target.sort()
+            source = [ids[id] for id in target]
+        self.source = source
+        self.target = target
+        self.foreign_key = foreign_key
+
+
+class GraphemyDataLoader(DataLoader):
+    """
+    A customized DataLoader that handles additional filtering mechanisms during data
+    retrieval processes. It is capable of using predefined filter methods to process data
+    based on request-specific parameters.
+
+    Attributes:
+        filter_method (callable): A method that applies additional filtering to the data
+            based on the request context and specified filters.
+        context: The context of the request, used to pass additional parameters to the
+            filter_method.
+
+    Methods:
+        load: Overridden to apply filters before returning the data, enhancing the
+            DataLoader's functionality to cater to complex querying needs.
+    """
+
+    def __init__(self, filter_method=None, context: dict = None, **kwargs):
+        self.filter_method = filter_method
+        self.context = context
+        super().__init__(**kwargs)
+
+    async def load(self, keys, filters: dict | None):
+        filters["keys"] = (
+            tuple(keys)
+            if isinstance(keys, list)
+            else keys.strip() if isinstance(keys, str) else keys
+        )
+        data = await super().load(dict_to_tuple(filters))
+        if self.filter_method:
+            data = self.filter_method(data, self.context)
+        return data
+
+
+def dict_to_tuple(data: dict) -> tuple:
+    """
+    Converts a dictionary into a tuple, recursively processing nested dictionaries
+    and lists to ensure they are in a hashable and comparable format. This is essential
+    for caching mechanisms within DataLoaders.
+
+    Args:
+        data (dict): The dictionary to be converted.
+
+    Returns:
+        tuple: A tuple representation of the original dictionary, suitable for use as
+            a key in caching operations.
+    """
+    result = []
+    for key, value in data.items():
+        if isinstance(value, DateFilter):
+            value = vars(value)
+        if isinstance(value, dict):
+            nested_tuples = dict_to_tuple(value)
+            result.append((key, nested_tuples))
+        elif isinstance(value, list):
+            nested_tuples = tuple(
+                sorted(
+                    (
+                        dict_to_tuple(item)
+                        if isinstance(item, dict) or isinstance(item, DateFilter)
+                        else item
+                    )
+                    for item in value
+                )
+            )
+            result.append((key, nested_tuples))
+        else:
+            result.append((key, value))
+    return tuple(sorted(result))