dmart 0.1.0__py3-none-any.whl

alembic/env.py

@@ -0,0 +1,91 @@
+from logging.config import fileConfig
+
+from sqlalchemy import engine_from_config
+from sqlalchemy import pool
+
+from alembic import context
+
+from data_adapters.sql.create_tables import \
+    metadata
+
+from utils.settings import settings
+
+# this is the Alembic Config object, which provides
+# access to the values within the .ini file in use.
+config = context.config
+
+# Interpret the config file for Python logging.
+# This line sets up loggers basically.
+if config.config_file_name is not None:
+    fileConfig(config.config_file_name)
+
+driver = settings.database_driver.replace('+asyncpg', '+psycopg')
+database_connection_string = f"{driver}://{settings.database_username}:{settings.database_password}@{settings.database_host}:{settings.database_port}"
+connection_string = f"{database_connection_string}/{settings.database_name}"
+config.set_main_option('sqlalchemy.url', connection_string)
+
+# add your model's MetaData object here
+# for 'autogenerate' support
+# from myapp import mymodel
+# target_metadata = mymodel.Base.metadata
+target_metadata = metadata #SQLModel.metadata
+print(metadata.tables.keys())
+# other values from the config, defined by the needs of env.py,
+# can be acquired:
+# my_important_option = config.get_main_option("my_important_option")
+# ... etc.
+
+
+def run_migrations_offline() -> None:
+    """Run migrations in 'offline' mode.
+
+    This configures the context with just a URL
+    and not an Engine, though an Engine is acceptable
+    here as well.  By skipping the Engine creation
+    we don't even need a DBAPI to be available.
+
+    Calls to context.execute() here emit the given string to the
+    script output.
+
+    """
+    url = config.get_main_option("sqlalchemy.url")
+    context.configure(
+        url=url,
+        target_metadata=target_metadata,
+        literal_binds=True,
+        dialect_opts={"paramstyle": "named"},
+    )
+
+    with context.begin_transaction():
+        context.run_migrations()
+
+
+def run_migrations_online() -> None:
+    """Run migrations in 'online' mode.
+
+    In this scenario we need to create an Engine
+    and associate a connection with the context.
+
+    """
+    connectable = engine_from_config(
+        config.get_section(config.config_ini_section, {}),
+        prefix="sqlalchemy.",
+        poolclass=pool.NullPool,
+    )
+
+    with connectable.connect() as connection:
+        context.configure(
+            connection=connection, target_metadata=target_metadata,
+            render_as_batch=True,
+            user_module_prefix="sqlmodel.sql.sqltypes.",
+
+        )
+
+        with context.begin_transaction():
+            context.run_migrations()
+
+
+if context.is_offline_mode():
+    run_migrations_offline()
+else:
+    run_migrations_online()

api/info/router.py

@@ -0,0 +1,109 @@
+# import asyncio
+import json
+from pathlib import Path
+from fastapi import APIRouter, Depends, status
+from utils.internal_error_code import InternalErrorCode
+from utils.settings import settings
+import models.api as api
+from datetime import datetime
+import subprocess
+from os import getpid
+import socket
+from utils.jwt import JWTBearer
+from fastapi.responses import ORJSONResponse
+
+router = APIRouter(default_response_class=ORJSONResponse)
+
+git_info: dict[str,str|None] = {}
+service_start_time: datetime = datetime.now()
+
+info_json_path = Path(__file__).resolve().parent.parent.parent / "info.json"
+if info_json_path.exists():
+    with open(info_json_path) as info:
+        git_info = json.load(info)
+else:
+    branch_cmd = "git rev-parse --abbrev-ref HEAD"
+    result, _ = subprocess.Popen(branch_cmd.split(" "), stdout=subprocess.PIPE, stderr=subprocess.PIPE).communicate()
+    branch = None if result is None or len(result) == 0 else result.decode().strip()
+
+    version_cmd = "git rev-parse --short HEAD"
+    result, _ = subprocess.Popen(version_cmd.split(" "), stdout=subprocess.PIPE, stderr=subprocess.PIPE).communicate()
+    version = None if result is None or len(result) == 0 else result.decode().strip()
+
+    tag_cmd = "git describe --tags"
+    result, _ = subprocess.Popen(tag_cmd.split(" "), stdout=subprocess.PIPE, stderr=subprocess.PIPE).communicate()
+    tag = None if result is None or len(result) == 0 else result.decode().strip()
+
+    version_date_cmd = "git show --pretty=format:'%ad'"
+    result, _ = subprocess.Popen(version_date_cmd.split(" "), stdout=subprocess.PIPE,
+                                 stderr=subprocess.PIPE).communicate()
+    version_date = None if result is None or len(result) == 0 else result.decode().split("\n")[0]
+
+    git_info = {
+        "commit_hash": version,
+        "date": version_date,
+        "branch": branch,
+        "tag": tag
+    }
+
+server = socket.gethostname()
+
+
+@router.get("/me", response_model=api.Response, response_model_exclude_none=True)
+async def get_me(shortname=Depends(JWTBearer())) -> api.Response:
+    return api.Response(status=api.Status.success, attributes={"shortname": shortname})
+
+
+@router.get("/settings", response_model=api.Response, response_model_exclude_none=True)
+async def get_settings(shortname=Depends(JWTBearer())) -> api.Response:
+    if shortname != 'dmart':
+        raise api.Exception(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            error=api.Error(
+                type="access",
+                code=InternalErrorCode.NOT_ALLOWED,
+                message="You don't have permission to this action [21]"
+            )
+        )
+    return api.Response(status=api.Status.success, attributes=settings.model_dump())
+
+
+@router.get("/manifest", response_model=api.Response, response_model_exclude_none=True)
+async def get_manifest(_=Depends(JWTBearer())) -> api.Response:
+    now = datetime.now()
+    manifest = {
+        "name": "DMART",
+        "type": "microservice",
+        "description": "Structured CMS/IMS",
+        "service_details": {
+            "server": server,
+            "process_id": getpid(),
+            "start_time": service_start_time.isoformat(),
+            "current_time": now.isoformat(),
+            "running_for": str(now - service_start_time)
+        },
+        "git": git_info,
+    }
+    return api.Response(status=api.Status.success, attributes=manifest)
+
+"""
+@router.get("/in-loop-tasks")
+async def get_in_loop_tasks(_=Depends(JWTBearer())) -> api.Response:
+    tasks = asyncio.all_tasks()
+
+    tasks_data: list[dict[str, str]] = []
+    for task in tasks:
+        tasks_data.append({
+            "name": task.get_name(),
+            "coroutine": str(task.get_coro()),
+            "stack": str(task.get_stack())
+        })
+
+    return api.Response(
+        status=api.Status.success,
+        attributes={
+            "tasks_count": len(tasks_data),
+            "tasks": tasks_data
+        },
+    )
+"""