square_database_structure 2.8.1__tar.gz

square_database_structure-2.8.1/PKG-INFO

@@ -0,0 +1,243 @@
+Metadata-Version: 2.3
+Name: square_database_structure
+Version: 2.8.1
+Summary: database scheme for my personal server.
+Keywords: database,sqlalchemy,utilities
+Author: Parth Mukesh Mangtani
+Author-email: Parth Mukesh Mangtani <thepmsquare@gmail.com>
+License: GPLv3
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Database
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Dist: sqlalchemy>=2.0.23
+Requires-Dist: psycopg2-binary>=2.9.9
+Requires-Dist: pytest>=8.0.0 ; extra == 'all'
+Requires-Dist: pytest>=8.0.0 ; extra == 'test'
+Requires-Python: >=3.12
+Project-URL: homepage, https://github.com/thepmsquare/square_database_structure
+Provides-Extra: all
+Provides-Extra: test
+Description-Content-Type: text/markdown
+
+# square_database_structure
+
+> 📌 versioning: see [CHANGELOG.md](./CHANGELOG.md).
+
+## about
+
+python module to define postgresql database schemas using sqlalchemy.
+
+## goals
+
+- clear database → schema → table hierarchy
+- reusable (template) across multiple projects
+- single source of truth for schema and data
+
+## installation
+
+```bash
+pip install square_database_structure
+```
+
+## usage
+
+this module organizes database schemas in a standardized folder structure where each top-level folder represents a
+database, and subfolders within it represent schemas. all mandatory components, such as `__init__.py` and tables.py,
+data.py, stored_procedures_and_functions need to follow this structure.
+
+### folder structure
+
+```
+square_database_structure/
+├───main.py                                       # global definition file (mandatory)
+├───create_database.py                            # global database creation file (mandatory)
+└───database1/                                    # each folder corresponds to a separate database
+    ├───__init__.py                               # contains the global name for the database (mandatory)
+    └───schema1/                                  # each subfolder corresponds to a schema within the database
+        ├───__init__.py                           # contains the global name for the schema (mandatory)
+        ├───data.py                               # contains the data for insertion for the schema (mandatory)
+        ├───enums.py                              # defines enums to be used in the schema (optional)
+        ├───tables.py                             # defines tables of the schema (mandatory)
+        └───stored_procedures_and_functions/      # contains stored procedures and functions for the schema (mandatory)
+            ├───__init__.py                       # contains logic to discover sql files (mandatory)
+            └───function1.sql                      # function or stored procedure sql file (optional)
+```
+
+- top-level folders: represent individual databases (e.g., database1).
+- subfolders: represent schemas within each database (e.g., public, schema1).
+- mandatory files:
+    - `__init__.py` (both at the database and schema level).
+    - tables.py within each schema.
+    - data.py within each schema.
+    - stored_procedures_and_functions package within each schema.
+
+### defining database and schema names in `__init__.py`
+
+each database and schema folder must contain an `__init__.py` file where the database and schema names are defined
+as global variables.
+
+#### example for database:
+
+```python
+# database1/__init__.py
+
+global_string_database_name = "database1"  # mandatory: database name
+```
+
+#### example for schema:
+
+```python
+# database1/schema1/__init__.py
+
+global_string_schema_name = "schema1"  # mandatory: schema name
+```
+
+### defining tables in tables.py
+
+each schema folder must contain a tables.py file where:
+
+- you must declare a Base object tied to the schema.
+- you can define table classes, extending the Base object.
+
+#### example tables.py:
+
+```python
+# tables.py
+from sqlalchemy import Column, Integer, String, MetaData
+from sqlalchemy.ext.declarative import declarative_base
+from square_database_structure.square.public import global_string_schema_name
+
+# 1. mandatory: declare Base with metadata pointing to the schema
+
+Base = declarative_base(metadata=MetaData(schema=global_string_schema_name))
+
+
+# 2.optional: define table classes by extending Base
+
+class App(Base):
+    __tablename__ = 'app'
+
+
+id = Column(Integer, primary_key=True)
+app_name = Column(String, nullable=False)
+```
+
+### defining data in data.py
+
+- you must declare a data_to_insert list to store optional data that may be inserted into the schema's tables.
+
+```python
+from square_database_structure.square.public.tables import App
+
+# 1. mandatory: initialize a list for optional data insertion
+data_to_insert = []
+# optional: append data to be inserted into the table
+data_to_insert.append(App(app_name="example_app"))
+```
+
+### defining function or stored procedure in stored_procedures_and_functions package
+
+- paste this logic in the `__init__.py` of this package to discover all sql files.
+
+```python
+from pathlib import Path
+
+directory = Path(__file__).parent
+stored_procedures_and_functions = []
+
+for file_path in directory.iterdir():
+    if file_path.is_file() and file_path.suffix == ".sql":
+        with file_path.open("r") as file:
+            content = file.read()
+            stored_procedures_and_functions.append(content)
+```
+
+- you can keep raw sql files each containing ideally 1 stored procedure or function.
+- the name of the file should ideally correspond to the function / procedure name.
+- this raw sql should be compatible with postgres database.
+
+```sql
+CREATE OR REPLACE FUNCTION add_user(
+    p_username VARCHAR,
+    p_email VARCHAR
+) RETURNS TEXT AS $$
+BEGIN
+    -- Insert a new user into the users table
+    INSERT INTO users (username, email)
+    VALUES (p_username, p_email);
+
+    -- Return a success message
+    RETURN 'User added successfully!';
+END;
+$$ LANGUAGE plpgsql;
+
+```
+
+### centralized definitions in main.py
+
+the main.py file is mandatory and contains a global list that maps databases to schemas and their corresponding table
+definitions. this list is manually created by the user (for now).
+
+#### example main.py:
+
+```python
+# main.py
+
+from square_database_structure.square.public import global_string_schema_name as schema1_name
+from square_database_structure.square.public.tables import Base as Schema1Base
+from square_database_structure.square.public.data import data_to_insert as schema1_data
+from square_database_structure.square.public.stored_procedures_and_functions import (
+    stored_procedures_and_functions as schema1_stored_procedures_and_functions)
+from square_database_structure.square import global_string_database_name as database1_name
+
+# global list that maps databases and schemas
+
+global_list_create = [
+    {
+        "database": database1_name,  # mandatory: database name
+        "schemas": [
+            {
+                "schema": schema1_name,  # mandatory: schema name
+                "base": Schema1Base,  # mandatory: base for this schema
+                "data_to_insert": schema1_data,  # mandatory: data to insert (even if empty)
+                "stored_procedures_and_functions": schema1_stored_procedures_and_functions,
+                # mandatory: stored procedures and functions (even if empty)
+            },
+        ],
+    }
+]
+```
+
+this file centralizes the definition of each database and schema, including the associated Base and data_to_insert for
+table definitions.
+
+### creating tables
+
+once you have defined your databases, schemas, and tables, you can create them in your PostgreSQL database by using the
+`create_database_and_tables` function.
+
+```python
+from square_database_structure import create_database_and_tables
+
+# define the database connection details
+db_username = "your_username"
+db_password = "your_password"
+db_ip = "localhost"
+db_port = 5432
+
+# call the function to create the database and tables
+create_database_and_tables(db_username, db_password, db_ip, db_port)
+```
+
+## env
+
+- python>=3.12.0
+- postgresql >= 13
+
+> feedback is appreciated. thank you!

square_database_structure-2.8.1/README.md

@@ -0,0 +1,216 @@
+# square_database_structure
+
+> 📌 versioning: see [CHANGELOG.md](./CHANGELOG.md).
+
+## about
+
+python module to define postgresql database schemas using sqlalchemy.
+
+## goals
+
+- clear database → schema → table hierarchy
+- reusable (template) across multiple projects
+- single source of truth for schema and data
+
+## installation
+
+```bash
+pip install square_database_structure
+```
+
+## usage
+
+this module organizes database schemas in a standardized folder structure where each top-level folder represents a
+database, and subfolders within it represent schemas. all mandatory components, such as `__init__.py` and tables.py,
+data.py, stored_procedures_and_functions need to follow this structure.
+
+### folder structure
+
+```
+square_database_structure/
+├───main.py                                       # global definition file (mandatory)
+├───create_database.py                            # global database creation file (mandatory)
+└───database1/                                    # each folder corresponds to a separate database
+    ├───__init__.py                               # contains the global name for the database (mandatory)
+    └───schema1/                                  # each subfolder corresponds to a schema within the database
+        ├───__init__.py                           # contains the global name for the schema (mandatory)
+        ├───data.py                               # contains the data for insertion for the schema (mandatory)
+        ├───enums.py                              # defines enums to be used in the schema (optional)
+        ├───tables.py                             # defines tables of the schema (mandatory)
+        └───stored_procedures_and_functions/      # contains stored procedures and functions for the schema (mandatory)
+            ├───__init__.py                       # contains logic to discover sql files (mandatory)
+            └───function1.sql                      # function or stored procedure sql file (optional)
+```
+
+- top-level folders: represent individual databases (e.g., database1).
+- subfolders: represent schemas within each database (e.g., public, schema1).
+- mandatory files:
+    - `__init__.py` (both at the database and schema level).
+    - tables.py within each schema.
+    - data.py within each schema.
+    - stored_procedures_and_functions package within each schema.
+
+### defining database and schema names in `__init__.py`
+
+each database and schema folder must contain an `__init__.py` file where the database and schema names are defined
+as global variables.
+
+#### example for database:
+
+```python
+# database1/__init__.py
+
+global_string_database_name = "database1"  # mandatory: database name
+```
+
+#### example for schema:
+
+```python
+# database1/schema1/__init__.py
+
+global_string_schema_name = "schema1"  # mandatory: schema name
+```
+
+### defining tables in tables.py
+
+each schema folder must contain a tables.py file where:
+
+- you must declare a Base object tied to the schema.
+- you can define table classes, extending the Base object.
+
+#### example tables.py:
+
+```python
+# tables.py
+from sqlalchemy import Column, Integer, String, MetaData
+from sqlalchemy.ext.declarative import declarative_base
+from square_database_structure.square.public import global_string_schema_name
+
+# 1. mandatory: declare Base with metadata pointing to the schema
+
+Base = declarative_base(metadata=MetaData(schema=global_string_schema_name))
+
+
+# 2.optional: define table classes by extending Base
+
+class App(Base):
+    __tablename__ = 'app'
+
+
+id = Column(Integer, primary_key=True)
+app_name = Column(String, nullable=False)
+```
+
+### defining data in data.py
+
+- you must declare a data_to_insert list to store optional data that may be inserted into the schema's tables.
+
+```python
+from square_database_structure.square.public.tables import App
+
+# 1. mandatory: initialize a list for optional data insertion
+data_to_insert = []
+# optional: append data to be inserted into the table
+data_to_insert.append(App(app_name="example_app"))
+```
+
+### defining function or stored procedure in stored_procedures_and_functions package
+
+- paste this logic in the `__init__.py` of this package to discover all sql files.
+
+```python
+from pathlib import Path
+
+directory = Path(__file__).parent
+stored_procedures_and_functions = []
+
+for file_path in directory.iterdir():
+    if file_path.is_file() and file_path.suffix == ".sql":
+        with file_path.open("r") as file:
+            content = file.read()
+            stored_procedures_and_functions.append(content)
+```
+
+- you can keep raw sql files each containing ideally 1 stored procedure or function.
+- the name of the file should ideally correspond to the function / procedure name.
+- this raw sql should be compatible with postgres database.
+
+```sql
+CREATE OR REPLACE FUNCTION add_user(
+    p_username VARCHAR,
+    p_email VARCHAR
+) RETURNS TEXT AS $$
+BEGIN
+    -- Insert a new user into the users table
+    INSERT INTO users (username, email)
+    VALUES (p_username, p_email);
+
+    -- Return a success message
+    RETURN 'User added successfully!';
+END;
+$$ LANGUAGE plpgsql;
+
+```
+
+### centralized definitions in main.py
+
+the main.py file is mandatory and contains a global list that maps databases to schemas and their corresponding table
+definitions. this list is manually created by the user (for now).
+
+#### example main.py:
+
+```python
+# main.py
+
+from square_database_structure.square.public import global_string_schema_name as schema1_name
+from square_database_structure.square.public.tables import Base as Schema1Base
+from square_database_structure.square.public.data import data_to_insert as schema1_data
+from square_database_structure.square.public.stored_procedures_and_functions import (
+    stored_procedures_and_functions as schema1_stored_procedures_and_functions)
+from square_database_structure.square import global_string_database_name as database1_name
+
+# global list that maps databases and schemas
+
+global_list_create = [
+    {
+        "database": database1_name,  # mandatory: database name
+        "schemas": [
+            {
+                "schema": schema1_name,  # mandatory: schema name
+                "base": Schema1Base,  # mandatory: base for this schema
+                "data_to_insert": schema1_data,  # mandatory: data to insert (even if empty)
+                "stored_procedures_and_functions": schema1_stored_procedures_and_functions,
+                # mandatory: stored procedures and functions (even if empty)
+            },
+        ],
+    }
+]
+```
+
+this file centralizes the definition of each database and schema, including the associated Base and data_to_insert for
+table definitions.
+
+### creating tables
+
+once you have defined your databases, schemas, and tables, you can create them in your PostgreSQL database by using the
+`create_database_and_tables` function.
+
+```python
+from square_database_structure import create_database_and_tables
+
+# define the database connection details
+db_username = "your_username"
+db_password = "your_password"
+db_ip = "localhost"
+db_port = 5432
+
+# call the function to create the database and tables
+create_database_and_tables(db_username, db_password, db_ip, db_port)
+```
+
+## env
+
+- python>=3.12.0
+- postgresql >= 13
+
+> feedback is appreciated. thank you!

square_database_structure-2.8.1/pyproject.toml

@@ -0,0 +1,38 @@
+[build-system]
+requires = ["uv-build"]
+build-backend = "uv_build"
+
+[project]
+name = "square_database_structure"
+version = "2.8.1"
+description = "database scheme for my personal server."
+readme = "README.md"
+readme-content-type = "text/markdown"
+requires-python = ">=3.12"
+license = { text = "GPLv3" }
+authors = [
+    { name = "Parth Mukesh Mangtani", email = "thepmsquare@gmail.com" },
+]
+urls = { homepage = "https://github.com/thepmsquare/square_database_structure" }
+keywords = ["database", "sqlalchemy", "utilities"]
+dependencies = [
+    "sqlalchemy>=2.0.23",
+    "psycopg2-binary>=2.9.9",
+]
+optional-dependencies = { all = ["pytest>=8.0.0"], test = ["pytest>=8.0.0"] }
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: GNU General Public License v3 (GPLv3)",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3 :: Only",
+    "Topic :: Database",
+    "Topic :: Software Development :: Libraries :: Python Modules"
+]
+
+[tool.uv.build-backend]
+module-name = "square_database_structure"
+module-root = ""
+source-include = ["square_database_structure/**/stored_procedures_and_functions/*.sql"]

square_database_structure-2.8.1/square_database_structure/__init__.py

@@ -0,0 +1 @@
+from square_database_structure.create_database import create_database_and_tables

square_database_structure-2.8.1/square_database_structure/create_database.py

@@ -0,0 +1,108 @@
+from psycopg2.errors import DuplicateDatabase
+from sqlalchemy import create_engine, inspect, text
+from sqlalchemy.orm import sessionmaker
+
+from square_database_structure.main import global_list_create
+
+
+def create_database_and_tables(
+    db_username: str,
+    db_password: str,
+    db_ip: str,
+    db_port: int,
+    drop_if_exists: bool = False,
+) -> None:
+    try:
+        local_list_create = global_list_create
+
+        for local_dict_database in local_list_create:
+            local_str_database_name = local_dict_database["database"]
+            local_str_postgres_url = (
+                f"postgresql://{db_username}:{db_password}@" f"{db_ip}:{str(db_port)}/"
+            )
+            postgres_engine = create_engine(local_str_postgres_url)
+            # Create database if not exists
+            try:
+                with postgres_engine.connect() as postgres_connection:
+                    postgres_connection.execute(text("commit"))
+                    postgres_connection.execute(
+                        text(f"CREATE DATABASE {local_str_database_name}")
+                    )
+            except Exception as e:
+                if isinstance(getattr(e, "orig"), DuplicateDatabase):
+                    if drop_if_exists:
+                        with postgres_engine.connect() as postgres_connection:
+                            postgres_connection.execute(text("commit"))
+                            postgres_connection.execute(
+                                text(
+                                    f"DROP DATABASE {local_str_database_name} WITH (FORCE)"
+                                )
+                            )
+                            postgres_connection.execute(
+                                text(f"CREATE DATABASE {local_str_database_name}")
+                            )
+                else:
+                    raise
+            # ===========================================
+            local_str_database_url = (
+                f"postgresql://{db_username}:{db_password}@"
+                f"{db_ip}:{str(db_port)}/{local_str_database_name}"
+            )
+            database_engine = create_engine(local_str_database_url)
+            with database_engine.connect() as database_connection:
+                for local_dict_schema in local_dict_database["schemas"]:
+                    local_str_schema_name = local_dict_schema["schema"]
+                    # Create schema if not exists
+                    if not database_engine.dialect.has_schema(
+                        database_connection, local_str_schema_name
+                    ):
+                        database_connection.execute(text("commit"))
+                        database_connection.execute(
+                            text(f"CREATE SCHEMA {local_str_schema_name}")
+                        )
+                    else:
+                        pass
+                    # ===========================================
+                    database_connection.execute(
+                        text(f"SET search_path TO {local_str_schema_name}")
+                    )
+
+                    inspector = inspect(database_engine)
+                    existing_table_names = inspector.get_table_names(
+                        schema=local_str_schema_name
+                    )
+
+                    base = local_dict_schema["base"]
+                    # Create tables if not exists
+                    base.metadata.create_all(database_engine)
+                    # ===========================================
+                    data_to_insert = local_dict_schema["data_to_insert"]
+                    local_object_session = sessionmaker(bind=database_engine)
+                    session = local_object_session()
+                    filtered_data_to_insert = [
+                        x
+                        for x in data_to_insert
+                        if x.__tablename__ not in existing_table_names
+                    ]
+                    # insert data for newly created tables
+                    try:
+                        session.add_all(filtered_data_to_insert)
+                        # ===========================================
+                        session.commit()
+                        session.close()
+                    except Exception:
+                        session.rollback()
+                        session.close()
+                        raise
+                    # create stored procedures
+                    stored_procedures_and_functions = local_dict_schema[
+                        "stored_procedures_and_functions"
+                    ]
+                    for (
+                        stored_procedures_and_function
+                    ) in stored_procedures_and_functions:
+                        database_connection.execute(
+                            text(stored_procedures_and_function)
+                        )
+    except Exception:
+        raise

square_database_structure-2.8.1/square_database_structure/main.py

@@ -0,0 +1,101 @@
+from square_database_structure.square import (
+    global_string_database_name as local_string_square_database_name,
+)
+from square_database_structure.square.authentication import (
+    global_string_schema_name as local_string_square_authentication_schema_name,
+)
+from square_database_structure.square.authentication.data import (
+    data_to_insert as local_list_square_authentication_data_to_insert,
+)
+from square_database_structure.square.authentication.stored_procedures_and_functions import (
+    stored_procedures_and_functions as local_list_square_authentication_stored_procedures_and_functions,
+)
+from square_database_structure.square.authentication.tables import (
+    Base as SquareAuthenticationBase,
+)
+from square_database_structure.square.email import (
+    global_string_schema_name as local_string_square_email_schema_name,
+)
+from square_database_structure.square.email.data import (
+    data_to_insert as local_list_square_email_data_to_insert,
+)
+from square_database_structure.square.email.stored_procedures_and_functions import (
+    stored_procedures_and_functions as local_list_square_email_stored_procedures_and_functions,
+)
+from square_database_structure.square.email.tables import (
+    Base as SquareEmailBase,
+)
+from square_database_structure.square.file_storage import (
+    global_string_schema_name as local_string_square_file_storage_schema_name,
+)
+from square_database_structure.square.file_storage.data import (
+    data_to_insert as local_list_square_file_storage_data_to_insert,
+)
+from square_database_structure.square.file_storage.stored_procedures_and_functions import (
+    stored_procedures_and_functions as local_list_square_file_storage_stored_procedures_and_functions,
+)
+from square_database_structure.square.file_storage.tables import (
+    Base as SquareFileStorageBase,
+)
+from square_database_structure.square.greeting import (
+    global_string_schema_name as local_string_square_greeting_schema_name,
+)
+from square_database_structure.square.greeting.data import (
+    data_to_insert as local_list_square_greeting_data_to_insert,
+)
+from square_database_structure.square.greeting.stored_procedures_and_functions import (
+    stored_procedures_and_functions as local_list_square_greeting_stored_procedures_and_functions,
+)
+from square_database_structure.square.greeting.tables import (
+    Base as SquareGreetingBase,
+)
+from square_database_structure.square.public import (
+    global_string_schema_name as local_string_square_public_schema_name,
+)
+from square_database_structure.square.public.data import (
+    data_to_insert as local_list_square_public_data_to_insert,
+)
+from square_database_structure.square.public.stored_procedures_and_functions import (
+    stored_procedures_and_functions as local_list_square_public_stored_procedures_and_functions,
+)
+from square_database_structure.square.public.tables import (
+    Base as SquarePublicBase,
+)
+
+global_list_create = [
+    {
+        "database": local_string_square_database_name,
+        "schemas": [
+            {
+                "schema": local_string_square_public_schema_name,
+                "base": SquarePublicBase,
+                "data_to_insert": local_list_square_public_data_to_insert,
+                "stored_procedures_and_functions": local_list_square_public_stored_procedures_and_functions,
+            },
+            {
+                "schema": local_string_square_file_storage_schema_name,
+                "base": SquareFileStorageBase,
+                "data_to_insert": local_list_square_file_storage_data_to_insert,
+                "stored_procedures_and_functions": local_list_square_file_storage_stored_procedures_and_functions,
+            },
+            {
+                "schema": local_string_square_authentication_schema_name,
+                "base": SquareAuthenticationBase,
+                "data_to_insert": local_list_square_authentication_data_to_insert,
+                "stored_procedures_and_functions": local_list_square_authentication_stored_procedures_and_functions,
+            },
+            {
+                "schema": local_string_square_greeting_schema_name,
+                "base": SquareGreetingBase,
+                "data_to_insert": local_list_square_greeting_data_to_insert,
+                "stored_procedures_and_functions": local_list_square_greeting_stored_procedures_and_functions,
+            },
+            {
+                "schema": local_string_square_email_schema_name,
+                "base": SquareEmailBase,
+                "data_to_insert": local_list_square_email_data_to_insert,
+                "stored_procedures_and_functions": local_list_square_email_stored_procedures_and_functions,
+            },
+        ],
+    }
+]

square_database_structure-2.8.1/square_database_structure/square/__init__.py

@@ -0,0 +1 @@
+global_string_database_name = "square"

square_database_structure-2.8.1/square_database_structure/square/authentication/__init__.py

@@ -0,0 +1 @@
+global_string_schema_name = "authentication"

square_database_structure-2.8.1/square_database_structure/square/authentication/data.py

@@ -0,0 +1 @@
+data_to_insert = []

square_database_structure-2.8.1/square_database_structure/square/authentication/enums.py

@@ -0,0 +1,17 @@
+from enum import Enum
+
+
+class RecoveryMethodEnum(Enum):
+    EMAIL = "EMAIL"
+    BACKUP_CODE = "BACKUP_CODE"
+
+
+class VerificationCodeTypeEnum(Enum):
+    EMAIL_VERIFICATION = "EMAIL_VERIFICATION"
+    EMAIL_RECOVERY = "EMAIL_RECOVERY"
+    BACKUP_CODE_RECOVERY = "BACKUP_CODE_RECOVERY"
+
+
+class AuthProviderEnum(Enum):
+    SELF = "SELF"
+    GOOGLE = "GOOGLE"

square_database_structure-2.8.1/square_database_structure/square/authentication/stored_procedures_and_functions/__init__.py

@@ -0,0 +1,10 @@
+from pathlib import Path
+
+directory = Path(__file__).parent
+stored_procedures_and_functions = []
+
+for file_path in directory.iterdir():
+    if file_path.is_file() and file_path.suffix == ".sql":
+        with file_path.open("r") as file:
+            content = file.read()
+            stored_procedures_and_functions.append(content)

square_database_structure-2.8.1/square_database_structure/square/authentication/tables.py

@@ -0,0 +1,242 @@
+from sqlalchemy import (
+    Column,
+    Integer,
+    MetaData,
+    DateTime,
+    text,
+    String,
+    ForeignKey,
+    Enum,
+    UniqueConstraint,
+    func,
+)
+from sqlalchemy.dialects.postgresql import UUID
+from sqlalchemy.orm import declarative_base
+
+from square_database_structure.square.authentication import global_string_schema_name
+from square_database_structure.square.authentication.enums import (
+    RecoveryMethodEnum,
+    VerificationCodeTypeEnum,
+    AuthProviderEnum,
+)
+from square_database_structure.square.file_storage.tables import File
+from square_database_structure.square.public.tables import App
+
+Base = declarative_base(metadata=MetaData(schema=global_string_schema_name))
+
+
+class User(Base):
+    __tablename__ = "user"
+
+    user_id = Column(
+        UUID,
+        primary_key=True,
+        nullable=False,
+        unique=True,
+        server_default=text("gen_random_uuid()"),
+    )
+    user_username = Column(String, nullable=False, unique=True, index=True)
+
+
+class UserAuthProvider(Base):
+    __tablename__ = "user_auth_provider"
+
+    user_auth_provider_id = Column(
+        Integer, primary_key=True, nullable=False, unique=True, autoincrement=True
+    )
+    user_id = Column(
+        UUID,
+        ForeignKey(User.user_id, ondelete="CASCADE", onupdate="CASCADE"),
+        nullable=False,
+    )
+    auth_provider = Column(
+        Enum(AuthProviderEnum, schema=global_string_schema_name),
+        nullable=False,
+    )
+    auth_provider_user_id = Column(String, nullable=True)
+    __table_args__ = (
+        UniqueConstraint(
+            "user_id",
+            "auth_provider",
+            name="uq_user_id_auth_provider",
+        ),
+        UniqueConstraint(
+            "auth_provider",
+            "auth_provider_user_id",
+            name="uq_auth_provider_auth_provider_user_id",
+        ),
+    )
+
+
+class UserCredential(Base):
+    __tablename__ = "user_credential"
+
+    user_credential_id = Column(
+        Integer, primary_key=True, nullable=False, unique=True, autoincrement=True
+    )
+    user_id = Column(
+        UUID,
+        ForeignKey(User.user_id, ondelete="CASCADE", onupdate="CASCADE"),
+        nullable=False,
+        unique=True,
+    )
+    user_credential_hashed_password = Column(String, nullable=False)
+
+
+class UserApp(Base):
+    __tablename__ = "user_app"
+
+    user_id = Column(
+        UUID,
+        ForeignKey(User.user_id, ondelete="CASCADE", onupdate="CASCADE"),
+        nullable=False,
+        primary_key=True,
+    )
+    app_id = Column(
+        Integer,
+        ForeignKey(App.app_id, ondelete="CASCADE", onupdate="CASCADE"),
+        nullable=False,
+        primary_key=True,
+    )
+
+
+class UserSession(Base):
+    __tablename__ = "user_session"
+
+    user_session_id = Column(
+        Integer, primary_key=True, unique=True, nullable=False, autoincrement=True
+    )
+    user_id = Column(
+        UUID,
+        ForeignKey(User.user_id, ondelete="CASCADE", onupdate="CASCADE"),
+        nullable=False,
+    )
+    app_id = Column(
+        Integer,
+        ForeignKey(App.app_id, ondelete="CASCADE", onupdate="CASCADE"),
+        nullable=False,
+    )
+    user_session_refresh_token = Column(
+        String,
+        nullable=False,
+        unique=True,
+    )
+    user_session_expiry_time = Column(DateTime(timezone=True), nullable=False)
+
+
+class UserProfile(Base):
+    __tablename__ = "user_profile"
+
+    user_profile_id = Column(
+        Integer, primary_key=True, unique=True, nullable=False, autoincrement=True
+    )
+    user_id = Column(
+        UUID,
+        ForeignKey(User.user_id, ondelete="CASCADE", onupdate="CASCADE"),
+        nullable=False,
+        unique=True,
+    )
+    user_profile_photo_storage_token = Column(
+        String,
+        ForeignKey(File.file_storage_token, ondelete="RESTRICT", onupdate="CASCADE"),
+        nullable=True,
+        unique=True,
+        default=None,
+    )
+    user_profile_email = Column(
+        String,
+        nullable=True,
+        unique=True,
+        default=None,
+    )
+    user_profile_email_verified = Column(
+        DateTime(timezone=True),
+        nullable=True,
+        default=None,
+    )
+    user_profile_phone_number_country_code = Column(
+        String,
+        nullable=True,
+        default=None,
+    )
+    user_profile_phone_number = Column(
+        String,
+        nullable=True,
+        default=None,
+    )
+    user_profile_first_name = Column(
+        String,
+        nullable=True,
+        default=None,
+    )
+    user_profile_last_name = Column(
+        String,
+        nullable=True,
+        default=None,
+    )
+    __table_args__ = (
+        UniqueConstraint(
+            "user_profile_phone_number_country_code",
+            "user_profile_phone_number",
+            name="uq_user_profile_phone_number",
+        ),
+    )
+
+
+class UserRecoveryMethod(Base):
+    __tablename__ = "user_recovery_method"
+
+    user_recovery_method_id = Column(
+        Integer, primary_key=True, unique=True, nullable=False, autoincrement=True
+    )
+    user_id = Column(
+        UUID,
+        ForeignKey(User.user_id, ondelete="CASCADE", onupdate="CASCADE"),
+        nullable=False,
+    )
+    user_recovery_method_name = Column(
+        Enum(RecoveryMethodEnum, schema=global_string_schema_name),
+        nullable=False,
+    )
+    __table_args__ = (
+        UniqueConstraint(
+            "user_id",
+            "user_recovery_method_name",
+            name="uq_user_id_user_recovery_method",
+        ),
+    )
+
+
+class UserVerificationCode(Base):
+    __tablename__ = "user_verification_code"
+
+    user_verification_code_id = Column(
+        Integer, primary_key=True, unique=True, nullable=False, autoincrement=True
+    )
+    user_id = Column(
+        UUID,
+        ForeignKey(User.user_id, ondelete="CASCADE", onupdate="CASCADE"),
+        nullable=False,
+    )
+    user_verification_code_type = Column(
+        Enum(VerificationCodeTypeEnum, schema=global_string_schema_name),
+        nullable=False,
+    )
+    user_verification_code_hash = Column(
+        String,
+        unique=True,
+        nullable=False,
+    )
+    user_verification_code_created_at = Column(
+        DateTime(timezone=True),
+        nullable=False,
+        server_default=func.now(),
+    )
+    user_verification_code_expires_at = Column(
+        DateTime(timezone=True),
+        nullable=True,
+    )
+    user_verification_code_used_at = Column(
+        DateTime(timezone=True),
+        nullable=True,
+    )

square_database_structure-2.8.1/square_database_structure/square/email/__init__.py

@@ -0,0 +1 @@
+global_string_schema_name = "email"

square_database_structure-2.8.1/square_database_structure/square/email/data.py

@@ -0,0 +1 @@
+data_to_insert = []

square_database_structure-2.8.1/square_database_structure/square/email/enums.py

@@ -0,0 +1,11 @@
+from enum import Enum
+
+
+class EmailTypeEnum(Enum):
+    VERIFY_EMAIL = "VERIFY_EMAIL"
+    PASSWORD_RESET = "PASSWORD_RESET"
+
+
+class EmailStatusEnum(Enum):
+    SENT = "SENT"
+    FAILED = "FAILED"

square_database_structure-2.8.1/square_database_structure/square/email/stored_procedures_and_functions/__init__.py

@@ -0,0 +1,10 @@
+from pathlib import Path
+
+directory = Path(__file__).parent
+stored_procedures_and_functions = []
+
+for file_path in directory.iterdir():
+    if file_path.is_file() and file_path.suffix == ".sql":
+        with file_path.open("r") as file:
+            content = file.read()
+            stored_procedures_and_functions.append(content)

square_database_structure-2.8.1/square_database_structure/square/email/tables.py

@@ -0,0 +1,57 @@
+from sqlalchemy import (
+    Column,
+    Integer,
+    MetaData,
+    DateTime,
+    String,
+    ForeignKey,
+    Enum,
+    func,
+)
+from sqlalchemy.dialects.postgresql import UUID
+from sqlalchemy.orm import declarative_base
+
+from square_database_structure.square.authentication.tables import User
+from square_database_structure.square.email import global_string_schema_name
+from square_database_structure.square.email.enums import EmailTypeEnum, EmailStatusEnum
+
+Base = declarative_base(metadata=MetaData(schema=global_string_schema_name))
+
+
+class EmailLog(Base):
+    __tablename__ = "email_log"
+
+    email_log_id = Column(
+        Integer, primary_key=True, unique=True, nullable=False, autoincrement=True
+    )
+    user_id = Column(
+        UUID,
+        ForeignKey(User.user_id, ondelete="SET NULL", onupdate="CASCADE"),
+        nullable=True,
+        index=True,
+    )
+    recipient_email = Column(
+        String,
+        nullable=False,
+        index=True,
+    )
+    email_type = Column(
+        Enum(EmailTypeEnum, schema=global_string_schema_name),
+        nullable=False,
+    )
+    sent_at = Column(
+        DateTime(timezone=True),
+        nullable=False,
+        server_default=func.now(),
+    )
+    status = Column(
+        Enum(EmailStatusEnum, schema=global_string_schema_name),
+        nullable=False,
+    )
+
+    third_party_message_id = Column(
+        String,
+        nullable=True,
+        unique=True,
+        index=True,
+    )

square_database_structure-2.8.1/square_database_structure/square/file_storage/__init__.py

@@ -0,0 +1 @@
+global_string_schema_name = "file_storage"

square_database_structure-2.8.1/square_database_structure/square/file_storage/data.py

@@ -0,0 +1 @@
+data_to_insert = []

square_database_structure-2.8.1/square_database_structure/square/file_storage/stored_procedures_and_functions/__init__.py

@@ -0,0 +1,10 @@
+from pathlib import Path
+
+directory = Path(__file__).parent
+stored_procedures_and_functions = []
+
+for file_path in directory.iterdir():
+    if file_path.is_file() and file_path.suffix == ".sql":
+        with file_path.open("r") as file:
+            content = file.read()
+            stored_procedures_and_functions.append(content)

square_database_structure-2.8.1/square_database_structure/square/file_storage/stored_procedures_and_functions/get_file_count.sql

@@ -0,0 +1,11 @@
+CREATE OR REPLACE FUNCTION get_file_count()
+RETURNS INTEGER AS $$
+DECLARE
+    file_count INTEGER;
+BEGIN
+    SELECT COUNT(*) INTO file_count
+    FROM file;
+
+    RETURN file_count;
+END;
+$$ LANGUAGE plpgsql;

square_database_structure-2.8.1/square_database_structure/square/file_storage/tables.py

@@ -0,0 +1,40 @@
+from sqlalchemy import (
+    Column,
+    DateTime,
+    Integer,
+    String,
+    MetaData,
+    ForeignKey,
+)
+from sqlalchemy.orm import declarative_base
+from sqlalchemy.sql import func
+
+from square_database_structure.square.file_storage import global_string_schema_name
+from square_database_structure.square.public.tables import App
+
+Base = declarative_base(metadata=MetaData(schema=global_string_schema_name))
+
+
+class File(Base):
+    __tablename__ = "file"
+
+    file_id = Column(Integer, autoincrement=True, primary_key=True, index=True)
+    file_name_with_extension = Column(String, nullable=False)
+    file_content_type = Column(String, nullable=False, index=True)
+    file_date_created = Column(
+        DateTime(timezone=True), server_default=func.now(), nullable=False
+    )
+    file_last_modified = Column(
+        DateTime(timezone=True),
+        server_default=func.now(),
+        onupdate=func.now(),
+        nullable=False,
+    )
+    file_system_file_name_with_extension = Column(String, nullable=False)
+    file_system_relative_path = Column(String, server_default="", nullable=False)
+    file_storage_token = Column(String, nullable=False, unique=True, index=True)
+    app_id = Column(
+        Integer,
+        ForeignKey(App.app_id, ondelete="CASCADE", onupdate="CASCADE"),
+        nullable=True,
+    )

square_database_structure-2.8.1/square_database_structure/square/greeting/__init__.py

@@ -0,0 +1 @@
+global_string_schema_name = "greeting"

square_database_structure-2.8.1/square_database_structure/square/greeting/data.py

@@ -0,0 +1 @@
+data_to_insert = []

square_database_structure-2.8.1/square_database_structure/square/greeting/stored_procedures_and_functions/__init__.py

@@ -0,0 +1,10 @@
+from pathlib import Path
+
+directory = Path(__file__).parent
+stored_procedures_and_functions = []
+
+for file_path in directory.iterdir():
+    if file_path.is_file() and file_path.suffix == ".sql":
+        with file_path.open("r") as file:
+            content = file.read()
+            stored_procedures_and_functions.append(content)

square_database_structure-2.8.1/square_database_structure/square/greeting/tables.py

@@ -0,0 +1,35 @@
+from sqlalchemy import (
+    MetaData,
+    Column,
+    Integer,
+    String,
+    Boolean,
+    ForeignKey,
+    DateTime,
+    func,
+)
+from sqlalchemy.dialects.postgresql import UUID
+from sqlalchemy.orm import declarative_base
+
+from square_database_structure.square.authentication.tables import User
+from square_database_structure.square.greeting import global_string_schema_name
+
+Base = declarative_base(metadata=MetaData(schema=global_string_schema_name))
+
+
+class Greeting(Base):
+    __tablename__ = "greeting"
+
+    greeting_id = Column(
+        Integer, primary_key=True, nullable=False, unique=True, autoincrement=True
+    )
+    greeting_is_anonymous = Column(Boolean, nullable=False)
+    greeting_anonymous_sender_name = Column(String)
+    user_id = Column(
+        UUID,
+        ForeignKey(User.user_id, ondelete="CASCADE", onupdate="CASCADE"),
+    )
+    greeting_text = Column(String)
+    greeting_datetime = Column(
+        DateTime(timezone=True), server_default=func.now(), nullable=False
+    )

square_database_structure-2.8.1/square_database_structure/square/public/__init__.py

@@ -0,0 +1 @@
+global_string_schema_name = "public"

square_database_structure-2.8.1/square_database_structure/square/public/data.py

@@ -0,0 +1,7 @@
+from square_database_structure.square.public.tables import App
+
+data_to_insert = []
+data_to_insert.append(App(app_name="test"))
+data_to_insert.append(App(app_name="square_admin"))
+data_to_insert.append(App(app_name="ttthree"))
+data_to_insert.append(App(app_name="square_wallet"))

square_database_structure-2.8.1/square_database_structure/square/public/enums.py

@@ -0,0 +1,8 @@
+import enum
+
+
+class TestEnumEnum(enum.Enum):
+    PENDING = "PENDING"
+    RUNNING = "RUNNING"
+    COMPLETED = "COMPLETED"
+    FAILED = "FAILED"

square_database_structure-2.8.1/square_database_structure/square/public/stored_procedures_and_functions/__init__.py

@@ -0,0 +1,10 @@
+from pathlib import Path
+
+directory = Path(__file__).parent
+stored_procedures_and_functions = []
+
+for file_path in directory.iterdir():
+    if file_path.is_file() and file_path.suffix == ".sql":
+        with file_path.open("r") as file:
+            content = file.read()
+            stored_procedures_and_functions.append(content)

square_database_structure-2.8.1/square_database_structure/square/public/stored_procedures_and_functions/get_test_text.sql

@@ -0,0 +1,12 @@
+CREATE OR REPLACE FUNCTION get_test_text(input_test_id INTEGER)
+RETURNS TEXT AS $$
+DECLARE
+    test_text TEXT;
+BEGIN
+    SELECT t.test_text INTO test_text
+    FROM test AS t
+    WHERE t.test_id = input_test_id;
+
+    RETURN test_text;
+END;
+$$ LANGUAGE plpgsql;

square_database_structure-2.8.1/square_database_structure/square/public/tables.py

@@ -0,0 +1,42 @@
+from sqlalchemy import (
+    Column,
+    Integer,
+    String,
+    DateTime,
+    Boolean,
+    Float,
+    JSON,
+    LargeBinary,
+    Enum,
+    MetaData,
+)
+from sqlalchemy.orm import declarative_base
+
+from square_database_structure.square.public import global_string_schema_name
+from square_database_structure.square.public.enums import TestEnumEnum
+
+Base = declarative_base(metadata=MetaData(schema=global_string_schema_name))
+
+
+class Test(Base):
+    __tablename__ = "test"
+
+    test_id = Column(
+        Integer, primary_key=True, nullable=False, unique=True, autoincrement=True
+    )
+    test_text = Column(String, nullable=True, unique=True)
+    test_datetime = Column(DateTime, nullable=True)
+    test_bool = Column(Boolean, nullable=True)
+    test_enum_enum = Column(Enum(TestEnumEnum), nullable=True)
+    test_float = Column(Float, nullable=True)
+    test_json = Column(JSON, nullable=True)
+    test_blob = Column(LargeBinary, nullable=True)
+
+
+class App(Base):
+    __tablename__ = "app"
+
+    app_id = Column(
+        Integer, primary_key=True, nullable=False, unique=True, autoincrement=True
+    )
+    app_name = Column(String, nullable=False, unique=True)