supabase-pydantic 0.2.1__tar.gz

supabase_pydantic-0.2.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Kevin Boehm <kmbhm1@gmail.com>
+
+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.

supabase_pydantic-0.2.1/PKG-INFO

@@ -0,0 +1,54 @@
+Metadata-Version: 2.1
+Name: supabase-pydantic
+Version: 0.2.1
+Summary: A project to translate Supabase schemas into Pydantic models
+License: MIT
+Author: K Boehm
+Author-email: kmbhm1@gmail.com
+Requires-Python: >=3.10,<4.0
+Classifier: Development Status :: 1 - Planning
+Classifier: Environment :: Console
+Classifier: Framework :: FastAPI
+Classifier: Framework :: Pydantic
+Classifier: Framework :: Pydantic :: 2
+Classifier: Framework :: Pytest
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Natural Language :: English
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: click (>=8.1.7,<9.0.0)
+Requires-Dist: faker (>=24.11.0,<25.0.0)
+Requires-Dist: isort (>=5.13.2,<6.0.0)
+Requires-Dist: psycopg2-binary (>=2.9.9,<3.0.0)
+Requires-Dist: pydantic (>=2.6.3,<3.0.0)
+Requires-Dist: python-dotenv (>=1.0.1,<2.0.0)
+Requires-Dist: types-psycopg2 (>=2.9.21.20240417,<3.0.0.0)
+Description-Content-Type: text/markdown
+
+# Supabase Pydantic Schemas
+
+A project for digesting Supabase (or Postgres) table & view schemas into Pydantic models. Currently, this is ideal for projects that integrate [FastAPI](https://fastapi.tiangolo.com/) with [Supabase-Python](https://supabase.com/docs/reference/python/introduction), but more updates are coming soon ...
+
+## Installation
+
+```bash
+$ pip install supabase-pydantic                 # install
+$ touch .env                                    # create .env file
+$ echo "DB_NAME=<your_db_name>" >> .env         # add your postgres db name
+$ echo "DB_USER=<your_db_user>" >> .env         # add your postgres db user
+$ echo "DB_PASS=<your_db_password>" >> .env     # add your postgres db password
+$ echo "DB_HOST=<your_db_host>" >> .env         # add your postgres db host
+$ echo "DB_PORT=<your_db_port>" >> .env         # add your postgres db port
+```
+
+## Usage
+
+```bash
+$ sb-pydantic  # generate default schemas.py to ./entities/fastapi
+```
+

supabase_pydantic-0.2.1/README.md

@@ -0,0 +1,21 @@
+# Supabase Pydantic Schemas
+
+A project for digesting Supabase (or Postgres) table & view schemas into Pydantic models. Currently, this is ideal for projects that integrate [FastAPI](https://fastapi.tiangolo.com/) with [Supabase-Python](https://supabase.com/docs/reference/python/introduction), but more updates are coming soon ...
+
+## Installation
+
+```bash
+$ pip install supabase-pydantic                 # install
+$ touch .env                                    # create .env file
+$ echo "DB_NAME=<your_db_name>" >> .env         # add your postgres db name
+$ echo "DB_USER=<your_db_user>" >> .env         # add your postgres db user
+$ echo "DB_PASS=<your_db_password>" >> .env     # add your postgres db password
+$ echo "DB_HOST=<your_db_host>" >> .env         # add your postgres db host
+$ echo "DB_PORT=<your_db_port>" >> .env         # add your postgres db port
+```
+
+## Usage
+
+```bash
+$ sb-pydantic  # generate default schemas.py to ./entities/fastapi
+```

supabase_pydantic-0.2.1/pyproject.toml

@@ -0,0 +1,211 @@
+[tool.poetry]
+name = "supabase-pydantic"
+version = "0.2.1"
+description = "A project to translate Supabase schemas into Pydantic models"
+authors = ["K Boehm <kmbhm1@gmail.com>"]
+license = "MIT"
+readme = "README.md"
+classifiers = [
+    "Development Status :: 1 - Planning",
+    "Environment :: Console",
+    "Framework :: FastAPI",
+    "Framework :: Pydantic",
+    "Framework :: Pydantic :: 2", 
+    "Framework :: Pytest",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Natural Language :: English",
+    "Operating System :: MacOS :: MacOS X", 
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+]
+
+[tool.poetry.scripts]
+sb-pydantic = 'supabase_pydantic.cli:main'
+supabase-pydantic = 'supabase_pydantic.cli:main'
+
+[tool.poetry.dependencies]
+python = "^3.10"
+psycopg2-binary = "^2.9.9"
+pydantic = "^2.6.3"
+types-psycopg2 = "^2.9.21.20240417"
+faker = "^24.11.0"
+isort = "^5.13.2"
+python-dotenv = "^1.0.1"
+click = "^8.1.7"
+
+[tool.poetry.group.dev.dependencies]
+ruff = "^0.4.1"
+sqlalchemy = {extras = ["mypy"], version = "^2.0.31"}
+fastapi-jsonapi = "^2.8.0"
+pytest = "^8.2.2"
+python-semantic-release = "^9.8.5"
+
+[tool.ruff]
+line-length = 120
+indent-width = 4
+target-version = "py310"
+
+[tool.ruff.lint]
+select = [
+    "E",  # pycodestyle
+    "F",  # Pyflakes
+    "UP", # pyupgrade
+    "D",  # pydocstyle
+    "I",  # isort
+    "Q",  # flake8-quotes
+    "W",  # pycodestyle
+]
+exclude = [
+    ".git",
+    ".venv",
+    "__pycache__",
+    "build",
+    "dist",
+    "docs",
+    # "notebooks",
+    "**/*tests*",
+    "scripts",
+    "setup.py",
+    "setup.cfg",
+    "pyproject.toml",
+    "poetry.lock",
+    "pyrightconfig.json",
+    ".*.yml",
+    ".*.yaml",
+    ".*.toml",
+    ".*.md",
+    ".*.txt",
+    ".*.rst",
+    ".*.json",
+    ".*.html",
+    ".*.css",
+    ".*.js",
+    ".*.png",
+    ".*.jpg",
+    ".*.jpeg",
+    ".*.gif",
+    ".*.svg",
+    ".*.ico",
+    ".*.eot",
+    ".*.ttf",
+    ".*.woff",
+    ".*.woff2",
+    ".*.map",
+    # ".*.ipynb",
+    ".*.pyi",
+    ".*.pyc",
+    ".*.pyd",
+    ".*.pyo",
+    ".*.pyw",
+    ".*.pyz",
+    ".*.pyzw",
+    ".*.DS_Store",
+    ".*.gitignore",
+    ".*.gitkeep",
+    ".*.gitmodules",
+    ".*.gitattributes",
+    ".*.git",
+    ".*.hgignore",
+    ".*.hgkeep",
+    ".*.",
+]
+ignore = [
+    "D100", # Missing docstring in public module
+    "D101", # Missing docstring in public class
+    "D104", # Missing docstring in public package
+    "D105", # Missing docstring in magic method
+    "D107", # Missing docstring in __init__
+    "D202", # No blank lines allowed after function docstring
+    "D206", # Docstring should be indented with spaces, not tabs
+    "E101", # indentation contains mixed spaces and tabs
+    "F403", # 'from module import *' used; unable to detect undefined names
+    "Q000", # Remove bad quotes
+    "Q002", # Remove bad quotes
+    "Q003", # Unnecessary single quotes
+    "W191", # Indentation contains tabs
+]
+
+[tool.ruff.lint.flake8-quotes]
+docstring-quotes = "single"
+
+[tool.ruff.lint.pydocstyle]
+convention = "google"
+
+[tool.ruff.format]
+quote-style = "single"
+indent-style = "space"
+skip-magic-trailing-comma = true
+line-ending = "auto"
+
+[tool.mypy]
+plugins = ["sqlalchemy.ext.mypy.plugin"]
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.semantic_release]
+allow_zero_version = true
+assets = []
+branch = "main"
+build_command = "poetry build"
+build_command_env = []
+changelog_file = "CHANGELOG.md"
+commit_message = "{version}\n\nAutomatically generated by python-semantic-release"
+commit_parser = "angular"
+dist_path = "dist/"
+logging_use_named_masks = false
+major_on_zero = true
+no_git_verify = false
+patch_without_tag = true
+remove_dist = false
+tag_format = "v{version}"
+upload_to_pypi = false
+upload_to_release = true
+version_toml = ["pyproject.toml:tool.poetry.version"]
+
+[tool.semantic_release.branches.main]
+match = "(main|master)"
+prerelease_token = "rc"
+prerelease = false
+
+[tool.semantic_release.changelog]
+changelog_file = "CHANGELOG.md"
+exclude_commit_patterns = []
+
+[tool.semantic_release.changelog.environment]
+block_start_string = "{%"
+block_end_string = "%}"
+variable_start_string = "{{"
+variable_end_string = "}}"
+comment_start_string = "{#"
+comment_end_string = "#}"
+trim_blocks = false
+lstrip_blocks = false
+newline_sequence = "\n"
+keep_trailing_newline = false
+extensions = []
+autoescape = true
+
+[tool.semantic_release.commit_author]
+env = "GIT_COMMIT_AUTHOR"
+default = "KB <kmbhm1@gmail.com>"
+
+[tool.semantic_release.commit_parser_options]
+allowed_tags = ["build", "chore", "ci", "docs", "feat", "feature", "fix", "perf", "style", "refactor", "test"]
+minor_tags = ["feat", "feature"]
+patch_tags = ["fix", "perf"]
+default_bump_level = 0
+
+[tool.semantic_release.remote]
+name = "origin"
+type = "github"
+ignore_token_for_push = false
+insecure = false
+
+[tool.semantic_release.publish]
+dist_glob_patterns = ["dist/*"]
+upload_to_vcs_release = true
+

supabase_pydantic-0.2.1/supabase_pydantic/cli.py

@@ -0,0 +1,125 @@
+import os
+import pprint
+
+from dotenv import find_dotenv, load_dotenv
+
+from supabase_pydantic.util import (
+    construct_table_info,
+    create_connection,
+    query_database,
+    check_connection,
+    GET_ALL_PUBLIC_TABLES_AND_COLUMNS,
+    GET_TABLE_COLUMN_DETAILS,
+    write_pydantic_model_string,
+    run_isort,
+    # write_sqlalchemy_model_string,
+    # write_jsonapi_pydantic_model_string,
+)
+from supabase_pydantic.util.constants import GET_CONSTRAINTS
+import click
+
+# Pretty print for testing
+pp = pprint.PrettyPrinter(indent=4)
+
+# Load environment variables from .env file
+load_dotenv(find_dotenv())
+
+# Replace these variables with your database connection details
+db_name = os.environ.get('DB_NAME')
+user = os.environ.get('DB_USER')
+password = os.environ.get('DB_PASS')
+host = os.environ.get('DB_HOST')
+port = os.environ.get('DB_PORT')
+
+
+def reload_env() -> tuple:
+    # Load environment variables from .env file
+    load_dotenv(find_dotenv())
+
+    # Replace these variables with your database connection details
+    db_name = os.environ.get('DB_NAME')
+    user = os.environ.get('DB_USER')
+    password = os.environ.get('DB_PASS')
+    host = os.environ.get('DB_HOST')
+    port = os.environ.get('DB_PORT')
+
+    return db_name, user, password, host, port
+
+
+def check_readiness():
+    """Check if environment variables are set correctly."""
+    # db_name, user, password, host, port = reload_env()
+    check = {'DB_NAME': db_name, 'DB_USER': user, 'DB_PASS': password, 'DB_HOST': host, 'DB_PORT': port}
+    for k, v in check.items():
+        # print(k, v)
+        if v is None:
+            print(f'Environment variables not set correctly. {k} is missing. Please set it in .env file.')
+            print('Exiting...')
+            return False
+
+    return True
+
+
+@click.command()
+@click.option('--directory', default='entities', help='The directory .')
+@click.option('--verbose', is_flag=True, help='Print verbose output.')
+def main(directory: str, verbose: bool = False):
+    """A CLI tool to generate Pydantic models from a PostgreSQL database."""
+
+    # Load environment variables from .env file & check if they are set correctly
+    load_dotenv(find_dotenv())
+    assert check_readiness()
+
+    default_directory = directory
+    # jsonapi_directory = os.path.join(default_directory, 'fastapi_jsonapi')
+    fastapi_directory = os.path.join(default_directory, 'fastapi')
+
+    try:
+        # Create a connection to the database & check if connection is successful
+        conn = create_connection(db_name, user, password, host, port)
+        assert check_connection(conn)
+
+        # Fetch table column details & foreign key details
+        column_details = query_database(conn, GET_ALL_PUBLIC_TABLES_AND_COLUMNS)
+        fk_details = query_database(conn, GET_TABLE_COLUMN_DETAILS)
+        constraints = query_database(conn, GET_CONSTRAINTS)
+        tables = construct_table_info(column_details, fk_details, constraints)
+    except Exception as e:
+        raise e
+    finally:
+        if conn:
+            conn.close()
+            print('Connection closed.')
+
+    # Create Pydantic models
+    pydantic_models_string = write_pydantic_model_string(tables)
+    pydantic_schemas_path = os.path.join(fastapi_directory, 'schemas.py')
+
+    # sql_alchemy_models_string = write_sqlalchemy_model_string(tables)
+    # sql_alchemy_models_path = os.path.join(jsonapi_directory, 'database.py')
+
+    # pydantic_jsonapi_models_string = write_jsonapi_pydantic_model_string(tables)
+    # pydantic_jsonapi_schemas_path = os.path.join(jsonapi_directory, 'schemas.py')
+
+    content = [pydantic_models_string]  # , sql_alchemy_models_string, pydantic_jsonapi_models_string]
+    path = [pydantic_schemas_path]  # , sql_alchemy_models_path, pydantic_jsonapi_schemas_path]
+
+    # Check if the directory exists, if not, create it
+    for d in [default_directory, fastapi_directory]:  # , jsonapi_directory]:
+        if not os.path.exists(d):
+            os.makedirs(d)
+
+    # Define the full path to the file
+    for s, fp in zip(content, path):
+        with open(fp, 'w') as file:
+            file.write(s)
+
+        try:
+            run_isort(fp)
+        except Exception as e:
+            print('An error occurred while running isort.')
+            print(e)
+
+
+if __name__ == '__main__':
+    main()

supabase_pydantic-0.2.1/supabase_pydantic/util/__init__.py

@@ -0,0 +1,43 @@
+from .constants import (
+    RelationType,
+    ModelGenerationType,
+    GET_ALL_PUBLIC_TABLES_AND_COLUMNS,
+    GET_TABLE_COLUMN_DETAILS,
+    PYDANTIC_TYPE_MAP,
+)
+from .json import CustomJsonEncoder
+from .fake import generate_fake_data
+from .dataclasses import AsDictParent, ColumnInfo, ForeignKeyInfo, TableInfo
+from .db import create_connection, query_database, check_connection
+from .marshalers import construct_table_info
+from .string import to_pascal_case
+from .generator_helpers import (
+    write_pydantic_model_string,
+    run_isort,
+    write_sqlalchemy_model_string,
+    write_jsonapi_pydantic_model_string,
+)
+
+__all__ = [
+    'to_pascal_case',
+    'create_connection',
+    'check_connection',
+    'CustomJsonEncoder',
+    'generate_fake_data',
+    'AsDictParent',
+    'ColumnInfo',
+    'ForeignKeyInfo',
+    'RelationType',
+    'Model',
+    'ModelGenerationType',
+    'GET_ALL_PUBLIC_TABLES_AND_COLUMNS',
+    'GET_TABLE_COLUMN_DETAILS',
+    'TableInfo',
+    'PYDANTIC_TYPE_MAP',
+    'construct_table_info',
+    'query_database',
+    'write_pydantic_model_string',
+    'run_isort',
+    'write_sqlalchemy_model_string',
+    'write_jsonapi_pydantic_model_string',
+]

supabase_pydantic-0.2.1/supabase_pydantic/util/constants.py

@@ -0,0 +1,128 @@
+from enum import Enum
+
+
+class RelationType(str, Enum):
+    ONE_TO_ONE = 'One-to-One'
+    ONE_TO_MANY = 'One-to-Many'
+    MANY_TO_MANY = 'Many-to-Many'
+
+
+class ModelGenerationType(str, Enum):
+    PARENT = 'PARENT'
+    MAIN = 'MAIN'
+
+
+CUSTOM_MODEL_NAME = 'CustomModel'
+CUSTOM_JSONAPI_META_MODEL_NAME = 'PydanticBaseModel'
+BASE_CLASS_POSTFIX = 'BaseSchema'
+
+CONSTRAINT_TYPE_MAP = {'p': 'PRIMARY KEY', 'f': 'FOREIGN KEY', 'u': 'UNIQUE', 'c': 'CHECK', 'x': 'EXCLUDE'}
+
+
+PYDANTIC_TYPE_MAP: dict[str, tuple[str, str | None]] = {
+    'integer': ('int', None),
+    'bigint': ('int', None),
+    'smallint': ('int', None),
+    'numeric': ('float', None),
+    'text': ('str', None),
+    'varchar': ('str', None),
+    'character varying': ('str', None),
+    'boolean': ('bool', None),
+    'timestamp': ('datetime', 'from datetime import datetime'),
+    'timestamp with time zone': ('datetime', 'from datetime import datetime'),
+    'timestamp without time zone': ('datetime', 'from datetime import datetime'),
+    'date': ('datetime.date', 'from datetime import date'),
+    'uuid': ('UUID4', 'from pydantic import UUID4'),
+    'json': ('dict | Json', 'from pydantic import Json'),
+    'jsonb': ('dict | Json', 'from pydantic import Json'),
+    'ARRAY': ('list', None),
+    # Add more data types and their imports as necessary.
+}
+
+
+SQLALCHEMY_TYPE_MAP: dict[str, tuple[str, str | None]] = {
+    'integer': ('Integer', 'from sqlalchemy import Integer'),
+    'bigint': ('BigInteger', 'from sqlalchemy import BigInteger'),
+    'smallint': ('SmallInteger', 'from sqlalchemy import SmallInteger'),
+    'numeric': ('Numeric', 'from sqlalchemy import Numeric'),
+    'text': ('Text', 'from sqlalchemy import Text'),
+    'varchar': ('String', 'from sqlalchemy import String'),
+    'character varying': ('String', 'from sqlalchemy import String'),
+    'boolean': ('Boolean', 'from sqlalchemy import Boolean'),
+    'timestamp': ('DateTime', 'from sqlalchemy import DateTime'),
+    'timestamp with time zone': ('DateTime', 'from sqlalchemy.dialects.postgresql import TIMESTAMP'),
+    'timestamp without time zone': ('DateTime', 'from sqlalchemy import DateTime'),
+    'date': ('Date', 'from sqlalchemy import Date'),
+    'uuid': ('UUID', 'from sqlalchemy.dialects.postgresql import UUID'),
+    'json': ('JSON', 'from sqlalchemy import JSON'),
+    'jsonb': ('JSONB', 'from sqlalchemy.dialects.postgresql import JSONB'),
+    'ARRAY': ('ARRAY', 'from sqlalchemy.dialects.postgresql import ARRAY'),
+    # Add more data types and their imports as necessary.
+}
+
+
+# Queries
+
+GET_TABLE_COLUMN_DETAILS = """
+SELECT
+    tc.table_schema,
+    tc.table_name,
+    kcu.column_name,
+    ccu.table_schema AS foreign_table_schema,
+    ccu.table_name AS foreign_table_name,
+    ccu.column_name AS foreign_column_name,
+    tc.constraint_name
+FROM
+    information_schema.table_constraints AS tc
+JOIN
+    information_schema.key_column_usage AS kcu
+  ON tc.constraint_name = kcu.constraint_name
+  AND tc.table_schema = kcu.table_schema
+JOIN
+    information_schema.constraint_column_usage AS ccu
+  ON ccu.constraint_name = tc.constraint_name
+  AND ccu.table_schema = tc.table_schema
+WHERE
+    tc.constraint_type = 'FOREIGN KEY'
+    AND tc.table_schema = 'public';
+"""
+
+GET_ALL_PUBLIC_TABLES_AND_COLUMNS = """
+SELECT
+    c.table_schema,
+    c.table_name,
+    c.column_name,
+    c.column_default,
+    c.is_nullable,
+    c.data_type,
+    c.character_maximum_length,
+    t.table_type
+FROM
+    information_schema.columns AS c
+JOIN
+    information_schema.tables AS t ON c.table_name = t.table_name AND c.table_schema = t.table_schema
+WHERE
+    c.table_schema = 'public'
+    AND (t.table_type = 'BASE TABLE' OR t.table_type = 'VIEW')
+ORDER BY
+    c.table_schema, c.table_name, c.ordinal_position;
+"""
+
+GET_CONSTRAINTS = """
+SELECT
+    conname AS constraint_name,
+    conrelid::regclass AS table_name,
+    array_agg(a.attname) AS columns,
+    contype AS constraint_type,
+    pg_get_constraintdef(oid) AS constraint_definition
+FROM
+    pg_constraint
+JOIN
+    pg_attribute AS a ON a.attnum = ANY (conkey) AND a.attrelid = conrelid
+WHERE
+    connamespace = (SELECT oid FROM pg_namespace WHERE nspname = 'public')
+GROUP BY
+    conname, conrelid, contype, oid
+ORDER BY
+    conrelid::regclass::text, contype DESC;
+"""