jetbase 0.0.1__tar.gz → 0.1.0__tar.gz

jetbase-0.1.0/.github/workflows/ci.yml

@@ -0,0 +1,99 @@
+name: CI
+
+on:
+  pull_request:
+    paths:
+      - "my_package/**" # only run when code inside my_package changes
+      - ".github/workflows/ci-pr.yml" # rerun if this workflow changes
+      - "pyproject.toml" # rerun if deps/config change
+      - "uv.lock" # rerun if lockfile changes
+  workflow_dispatch: {}
+jobs:
+  lint-type-format-checks:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v5
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.10"
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v6
+
+      - name: Install dependencies
+        run: uv sync --dev
+
+      - name: Pyrefly type checker
+        run: uv run pyrefly check
+
+      - name: Ruff linter
+        run: uv run ruff check jetbase tests
+
+      - name: Ruff formatter
+        run: uv run ruff format jetbase tests --check
+
+  unit-tests:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v5
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.10"
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v6
+
+      - name: Install dependencies
+        run: uv sync --dev
+
+      - name: Run unit tests
+        run: uv run pytest tests/core/ -v
+
+  integration-tests:
+    runs-on: ubuntu-latest
+
+    env:
+      DATABASE_URL: postgresql://postgres:postgres@localhost:5432/test_db
+
+    services:
+      postgres:
+        image: postgres:15
+        env:
+          POSTGRES_USER: postgres
+          POSTGRES_PASSWORD: postgres
+          POSTGRES_DB: test_db
+        options: >-
+          --health-cmd pg_isready
+          --health-interval 10s
+          --health-timeout 5s
+          --health-retries 5
+        ports:
+          - 5432:5432
+
+    steps:
+      - uses: actions/checkout@v5
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.10"
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v6
+
+      - name: Install dependencies
+        run: uv sync --dev
+
+      - name: Run jetbase
+        working-directory: tests/test_integration/jetbase
+        run: uv run jetbase upgrade
+
+      - name: Run integration tests
+        working-directory: tests/test_integration
+        run: uv run pytest

jetbase-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,35 @@
+name: Publish to PyPI
+
+on:
+  release:
+    types: [published]
+
+  workflow_dispatch:
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    if: github.actor == 'jaz-alli'
+
+    permissions:
+      id-token: write
+      contents: read
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.10"
+
+      - name: Build package
+        run: |
+          pip install build
+          python -m build
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          attestations: true

{jetbase-0.0.1 → jetbase-0.1.0}/.gitignore

@@ -172,3 +172,6 @@ cython_debug/
 
 # PyPI configuration file
 .pypirc
+
+# Other files and folders
+.python-version

jetbase-0.1.0/.pre-commit-config.yaml

@@ -0,0 +1,14 @@
+repos:
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.14.1
+    hooks:
+      - id: ruff-check
+        args: ["--select", "I", "--fix"]
+      - id: ruff-format
+
+  - repo: https://github.com/facebook/pyrefly-pre-commit
+    rev: 0.0.1
+    hooks:
+      - id: pyrefly-typecheck-system
+        name: Pyrefly
+        pass_filenames: false

{jetbase-0.0.1 → jetbase-0.1.0}/PKG-INFO

@@ -1,10 +1,11 @@
 Metadata-Version: 2.4
 Name: jetbase
-Version: 0.0.1
+Version: 0.1.0
 Summary: Jetbase is a Python database migration tool
 Author-email: jaz <jaz.allibhai@gmail.com>
 License-File: LICENSE
-Requires-Python: >=3.9
+Requires-Python: >=3.10
+Requires-Dist: sqlalchemy>=2.0.44
 Description-Content-Type: text/markdown
 
 # jetbase

jetbase-0.1.0/jetbase/cli/main.py

@@ -0,0 +1,19 @@
+import argparse
+
+from jetbase.core.initialize import initilize_jetbase
+from jetbase.core.upgrade import upgrade
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Jetbase CLI")
+
+    subparsers = parser.add_subparsers(dest="command", help="Available commands")
+    subparsers.add_parser("init", help="Initialize jetbase in current directory")
+    subparsers.add_parser("upgrade", help="Execute pending migrations")
+
+    args = parser.parse_args()
+
+    if args.command == "init":
+        initilize_jetbase()
+    elif args.command == "upgrade":
+        upgrade()

jetbase-0.1.0/jetbase/config.py

@@ -0,0 +1,60 @@
+import importlib.machinery
+import importlib.util
+import os
+
+# from importlib import ModuleType
+from types import ModuleType
+from typing import Any
+
+from jetbase.constants import CONFIG_FILE
+
+
+def get_sqlalchemy_url(filename: str = CONFIG_FILE) -> str:
+    """
+    Load a config file and extract the sqlalchemy_url.
+
+    Args:
+        config_filename: Name of the config file (e.g., "config.py")
+
+    Returns:
+        The sqlalchemy_url from the config file, or None if not found
+    """
+    config_path: str = os.path.join(os.getcwd(), filename)
+    spec: importlib.machinery.ModuleSpec | None = (
+        importlib.util.spec_from_file_location("config", config_path)
+    )
+
+    assert spec is not None
+    assert spec.loader is not None
+
+    config: ModuleType = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module=config)
+
+    raw_sqlalchemy_url: Any | None = getattr(config, "sqlalchemy_url", None)
+
+    if raw_sqlalchemy_url is None:
+        raise AttributeError(
+            f"'sqlalchemy_url' not found or is set to None. Please define it in {config_path}."
+        )
+
+    sqlalchemy_url: str = _validate_sqlalchemy_url(url=raw_sqlalchemy_url)
+
+    return sqlalchemy_url
+
+
+def _validate_sqlalchemy_url(url: Any) -> str:
+    """
+    Validates a SQLAlchemy URL string.
+    This function checks if the provided URL is a valid string.
+    Args:
+        url (Any): The SQLAlchemy URL to validate (could be any type from user config).
+    Returns:
+        str: The validated SQLAlchemy URL string.
+    Raises:
+        TypeError: If the provided URL is not a string.
+    """
+
+    if not isinstance(url, str):
+        raise TypeError(f"sqlalchemy_url must be a string, got {type(url).__name__}")
+
+    return url

jetbase-0.1.0/jetbase/constants.py

@@ -0,0 +1,12 @@
+from typing import Final
+
+BASE_DIR: Final[str] = "jetbase"
+MIGRATIONS_DIR: Final[str] = "migrations"
+CONFIG_FILE: Final[str] = "config.py"
+
+CONFIG_FILE_CONTENT: Final[str] = """
+# Jetbase Configuration
+# Update the sqlalchemy_url with your database connection string.
+
+sqlalchemy_url = "postgresql://user:password@localhost:5432/mydb"
+"""

jetbase-0.1.0/jetbase/core/file_parser.py

@@ -0,0 +1,29 @@
+def parse_sql_file(file_path: str) -> list[str]:
+    """
+    Parse a SQL file and return a list of SQL statements.
+
+    Args:
+        file_path (str): Path to the SQL file
+
+    Returns:
+        list[str]: List of SQL statements
+    """
+    statements = []
+    current_statement = []
+
+    with open(file_path, "r") as file:
+        for line in file:
+            line = line.strip()
+
+            if not line or line.startswith("--"):
+                continue
+            current_statement.append(line)
+
+            if line.endswith(";"):
+                statement = " ".join(current_statement)
+                statement = statement.rstrip(";").strip()
+                if statement:
+                    statements.append(statement)
+                current_statement = []
+
+    return statements

jetbase-0.1.0/jetbase/core/initialize.py

@@ -0,0 +1,33 @@
+from pathlib import Path
+
+from jetbase.constants import BASE_DIR, CONFIG_FILE, CONFIG_FILE_CONTENT, MIGRATIONS_DIR
+
+
+def create_directory_structure(base_path: str) -> None:
+    """
+    Create the basic directory structure for a new Jetbase project.
+
+    This function creates:
+    - A migrations directory
+    - A config file with default content
+
+    After creating the structure, it prints a confirmation message.
+
+    Args:
+        base_path (str): The base path where the Jetbase project structure will be created
+
+    Returns:
+        None
+    """
+    migrations_dir: Path = Path(base_path) / MIGRATIONS_DIR
+    migrations_dir.mkdir(parents=True, exist_ok=True)
+
+    config_path: Path = Path(base_path) / CONFIG_FILE
+    with open(config_path, "w") as f:
+        f.write(CONFIG_FILE_CONTENT)
+
+    print(f"Initialized Jetbase project in {Path(base_path).absolute()}")
+
+
+def initilize_jetbase() -> None:
+    create_directory_structure(base_path=BASE_DIR)

jetbase-0.1.0/jetbase/core/repository.py

@@ -0,0 +1,59 @@
+from sqlalchemy import Engine, Result, create_engine, text
+
+from jetbase.config import get_sqlalchemy_url
+from jetbase.queries import (
+    CREATE_MIGRATIONS_TABLE_STMT,
+    INSERT_VERSION_STMT,
+    LATEST_VERSION_QUERY,
+)
+
+
+def get_last_updated_version() -> str | None:
+    """
+    Retrieves the latest version from the database.
+    This function connects to the database, executes a query to get the most recent version,
+    and returns that version as a string.
+    Returns:
+        str | None: The latest version string if available, None if no version was found.
+    """
+
+    engine: Engine = create_engine(url=get_sqlalchemy_url())
+
+    with engine.begin() as connection:
+        result: Result[tuple[str]] = connection.execute(LATEST_VERSION_QUERY)
+        latest_version: str | None = result.scalar()
+    if not latest_version:
+        return None
+    return latest_version
+
+
+def create_migrations_table() -> None:
+    """
+    Creates the migrations table in the database
+    if it does not already exist.
+    Returns:
+        None
+    """
+
+    engine: Engine = create_engine(url=get_sqlalchemy_url())
+    with engine.begin() as connection:
+        connection.execute(statement=CREATE_MIGRATIONS_TABLE_STMT)
+
+
+def run_migration(sql_statements: list[str], version: str) -> None:
+    """
+    Execute a database migration by running SQL statements and recording the migration version.
+    Args:
+        sql_statements (list[str]): List of SQL statements to execute as part of the migration
+        version (str): Version identifier to record after successful migration
+    Returns:
+        None
+    """
+
+    engine: Engine = create_engine(url=get_sqlalchemy_url())
+    with engine.begin() as connection:
+        for statement in sql_statements:
+            connection.execute(text(statement))
+        connection.execute(
+            statement=INSERT_VERSION_STMT, parameters={"version": version}
+        )

jetbase-0.1.0/jetbase/core/upgrade.py

@@ -0,0 +1,34 @@
+import os
+
+from jetbase.core.file_parser import parse_sql_file
+from jetbase.core.repository import (
+    create_migrations_table,
+    get_last_updated_version,
+    run_migration,
+)
+from jetbase.core.version import get_versions
+
+
+def upgrade() -> None:
+    """
+    Run database migrations by applying all pending SQL migration files.
+    Executes migration files in order starting from the last applied version,
+    updating the migrations tracking table after each successful migration.
+
+    Returns:
+        None
+    """
+
+    create_migrations_table()
+    latest_version: str | None = get_last_updated_version()
+    all_versions = get_versions(
+        directory=os.path.join(os.getcwd(), "migrations"),
+        version_to_start_from=latest_version,
+    )
+
+    for version, file_path in all_versions.items():
+        sql_statements: list[str] = parse_sql_file(file_path)
+        run_migration(sql_statements=sql_statements, version=version)
+        filename: str = os.path.basename(file_path)
+
+        print(f"Migration applied successfully: {filename}")

jetbase-0.1.0/jetbase/core/version.py

@@ -0,0 +1,117 @@
+import os
+
+
+def _get_version_key_from_filename(filename: str) -> str:
+    """
+    Extract and normalize version key from a filename.
+
+    The function extracts the version part from a filename that follows the format:
+    'V{version}__{description}.sql' where version can be like '1', '1_1', or '1.1'.
+
+    Args:
+        filename (str): The filename to extract version from.
+            Must follow pattern like 'V1__description.sql' or 'V1_1__description.sql'
+
+    Returns:
+        str: Normalized version string where underscores are replaced with periods.
+
+    Raises:
+        ValueError: If the filename doesn't follow the expected format.
+
+    Examples:
+        >>> _get_version_key_from_filename("V1__my_description.sql")
+        '1'
+        >>> _get_version_key_from_filename("V1_1__my_description.sql")
+        '1.1'
+        >>> _get_version_key_from_filename("V1.1__my_description.sql")
+        '1.1'
+    """
+    try:
+        version = filename.split("__")[0][1:]
+    except Exception:
+        raise (
+            ValueError(
+                "Filename must be in the following format: V1__my_description.sql, V1_1__my_description.sql, V1.1__my_description.sql"
+            )
+        )
+    return version.replace("_", ".")
+
+
+def _convert_version_tuple_to_str(version_tuple: tuple[str, ...]) -> str:
+    """
+    Convert a version tuple to a string representation.
+
+    Args:
+        version_tuple (tuple[str, ...]): A tuple containing version components as strings.
+
+    Returns:
+        str: A string representation of the version, with components joined by periods.
+
+    Example:
+        >>> _convert_version_tuple_to_str(('1', '2', '3'))
+        '1.2.3'
+    """
+    return ".".join(version_tuple)
+
+
+def convert_version_to_tuple(version: str) -> tuple[str, ...]:
+    """
+    Convert a version string to a tuple of version components.
+
+    Args:
+        version_str (str): A version string with components separated by periods.
+
+    Returns:
+        tuple[str, ...]: A tuple containing the version components as strings.
+
+    Example:
+        >>> convert_version_to_tuple("1.2.3")
+        ('1', '2', '3')
+    """
+    return tuple(version.split("."))
+
+
+def get_versions(
+    directory: str, version_to_start_from: str | None = None
+) -> dict[str, str]:
+    """
+    Retrieves SQL files from the specified directory and organizes them by version.
+    This function walks through the directory tree, collects all SQL files, and creates a dictionary
+    mapping version strings to file paths. Files can be filtered to only include versions greater
+    than a specified starting version.
+    Args:
+        directory: The directory path to search for SQL files
+        version_to_start_from: Optional version string to filter results, only returning
+                              versions greater than this value
+    Returns:
+        A dictionary mapping version strings to file paths, sorted by version number
+    Example:
+        >>> get_versions('/path/to/sql/files')
+        {'1.0.0': '/path/to/sql/files/v1_0_0__description.sql', '1.2.0': '/path/to/sql/files/v1_2_0__description.sql'}
+    """
+    version_to_filepath_dict: dict[str, str] = {}
+    for root, _, files in os.walk(directory):
+        for file in files:
+            if file.endswith(".sql"):
+                file_path: str = os.path.join(root, file)
+                version: str = _get_version_key_from_filename(filename=file)
+                version_tuple: tuple[str, ...] = convert_version_to_tuple(
+                    version=version
+                )
+                if version_to_start_from:
+                    if version_tuple > convert_version_to_tuple(
+                        version=version_to_start_from
+                    ):
+                        version_to_filepath_dict[
+                            _convert_version_tuple_to_str(version_tuple=version_tuple)
+                        ] = file_path
+                else:
+                    version_to_filepath_dict[
+                        _convert_version_tuple_to_str(version_tuple=version_tuple)
+                    ] = file_path
+    ordered_version_to_filepath_dict: dict[str, str] = {
+        version: version_to_filepath_dict[version]
+        for version in sorted(version_to_filepath_dict.keys())
+    }
+
+    return ordered_version_to_filepath_dict

jetbase-0.1.0/jetbase/queries.py

@@ -0,0 +1,23 @@
+from sqlalchemy import TextClause, text
+
+LATEST_VERSION_QUERY: TextClause = text("""
+    SELECT 
+        version 
+    FROM 
+        jetbase_migrations
+    ORDER BY 
+        created_at DESC
+    LIMIT 1
+""")
+
+CREATE_MIGRATIONS_TABLE_STMT: TextClause = text("""
+CREATE TABLE IF NOT EXISTS jetbase_migrations (
+    version VARCHAR(255) PRIMARY KEY,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+)
+""")
+
+INSERT_VERSION_STMT: TextClause = text("""
+INSERT INTO jetbase_migrations (version) 
+VALUES (:version)
+""")

jetbase-0.1.0/pyproject.toml

@@ -0,0 +1,30 @@
+[project]
+name = "jetbase"
+version = "0.1.0"
+description = "Jetbase is a Python database migration tool"
+readme = "README.md"
+authors = [
+    { name = "jaz", email = "jaz.allibhai@gmail.com" }
+]
+requires-python = ">=3.10"
+dependencies = [
+    "sqlalchemy>=2.0.44",
+]
+
+[project.scripts]
+jetbase = "jetbase.cli.main:main"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["jetbase"]
+
+[dependency-groups]
+dev = [
+    "psycopg2-binary>=2.9.11",
+    "pyrefly>=0.38.2",
+    "pytest>=8.4.2",
+    "ruff>=0.14.2",
+]