Buckets:

download
raw
12.8 kB
"""
BLOOM ↔ TapDB Adapter Module.
This adapter delegates connection resolution and runtime behavior to
daylily-tapdb while exposing BLOOM ORM class wiring.
"""
from __future__ import annotations
import logging
from types import SimpleNamespace
from typing import Optional
from daylily_tapdb import TAPDBConnection
from daylily_tapdb.models.audit import audit_log
from daylily_tapdb.models.base import Base as TapDBBase
from daylily_tapdb.models.base import tapdb_core
from daylily_tapdb.models.instance import (
action_instance,
actor_instance,
container_instance,
content_instance,
data_instance,
equipment_instance,
file_instance,
generic_instance,
health_event_instance,
subject_instance,
workflow_instance,
workflow_step_instance,
)
from daylily_tapdb.models.lineage import (
action_instance_lineage,
actor_instance_lineage,
container_instance_lineage,
content_instance_lineage,
data_instance_lineage,
equipment_instance_lineage,
file_instance_lineage,
generic_instance_lineage,
health_event_instance_lineage,
subject_instance_lineage,
workflow_instance_lineage,
workflow_step_instance_lineage,
)
from daylily_tapdb.models.template import (
action_template,
actor_template,
container_template,
content_template,
data_template,
equipment_template,
file_template,
generic_template,
health_event_template,
subject_template,
workflow_step_template,
workflow_template,
)
from sqlalchemy import text
from sqlalchemy.orm import Session, object_session
from bloom_lims.config import (
apply_runtime_environment,
get_settings,
get_tapdb_db_config,
)
from bloom_lims.tapdb_metrics import db_username_var, maybe_install_engine_metrics
_KNOWN_LINEAGE_IDENTITIES = (
"generic_instance_lineage",
"workflow_instance_lineage",
"workflow_step_instance_lineage",
"container_instance_lineage",
"content_instance_lineage",
"equipment_instance_lineage",
"data_instance_lineage",
"test_requisition_instance_lineage",
"actor_instance_lineage",
"action_instance_lineage",
"health_event_instance_lineage",
"file_instance_lineage",
"subject_instance_lineage",
)
class _LineageQueryProxy:
"""Lightweight proxy that preserves iterable/.all() behavior for lineage access."""
def __init__(self, query):
self._query = query
def __iter__(self):
return iter(self._query)
def __len__(self):
if isinstance(self._query, list):
return len(self._query)
return self._query.count()
def __bool__(self):
if isinstance(self._query, list):
return bool(self._query)
return self._query.first() is not None
def all(self):
if isinstance(self._query, list):
return list(self._query)
return self._query.all()
def first(self):
if isinstance(self._query, list):
return self._query[0] if self._query else None
return self._query.first()
def count(self):
if isinstance(self._query, list):
return len(self._query)
return self._query.count()
def __getitem__(self, item):
return self._query[item]
def __getattr__(self, name):
return getattr(self._query, name)
def _query_lineages_for_instance(instance, *, fk_attr_name: str):
"""Return a query-like proxy for lineage traversal using canonical TapDB FKs."""
session = object_session(instance)
if session is None:
return _LineageQueryProxy([])
lineage_attr = getattr(generic_instance_lineage, fk_attr_name)
query = (
session.query(generic_instance_lineage)
.filter(lineage_attr == instance.uid)
.filter(
generic_instance_lineage.polymorphic_discriminator.in_(
_KNOWN_LINEAGE_IDENTITIES
)
)
)
return _LineageQueryProxy(query)
def get_parent_lineages(instance):
"""Return parent->child lineages using canonical TapDB FKs."""
return _query_lineages_for_instance(instance, fk_attr_name="parent_instance_uid")
def get_child_lineages(instance):
"""Return child->parent lineages using canonical TapDB FKs."""
return _query_lineages_for_instance(instance, fk_attr_name="child_instance_uid")
def _query_instance_for_lineage(lineage, *, fk_attr_name: str):
"""Resolve parent/child instance via explicit query against canonical TapDB FKs."""
session = object_session(lineage)
if session is None:
return None
instance_uid = getattr(lineage, fk_attr_name, None)
if instance_uid is None:
return None
return (
session.query(generic_instance)
.filter(generic_instance.uid == instance_uid)
.first()
)
file_set_template = file_template
file_reference_template = file_template
file_set_instance = file_instance
file_reference_instance = file_instance
file_set_instance_lineage = file_instance_lineage
file_reference_instance_lineage = file_instance_lineage
bloom_core = tapdb_core
_COMPAT_BASE_CLASSES = SimpleNamespace(
generic_template=generic_template,
generic_instance=generic_instance,
generic_instance_lineage=generic_instance_lineage,
workflow_template=workflow_template,
workflow_step_template=workflow_step_template,
container_template=container_template,
content_template=content_template,
equipment_template=equipment_template,
data_template=data_template,
actor_template=actor_template,
action_template=action_template,
health_event_template=health_event_template,
file_template=file_template,
file_set_template=file_set_template,
file_reference_template=file_reference_template,
subject_template=subject_template,
workflow_instance=workflow_instance,
workflow_step_instance=workflow_step_instance,
container_instance=container_instance,
content_instance=content_instance,
equipment_instance=equipment_instance,
data_instance=data_instance,
actor_instance=actor_instance,
action_instance=action_instance,
health_event_instance=health_event_instance,
file_instance=file_instance,
file_set_instance=file_set_instance,
file_reference_instance=file_reference_instance,
subject_instance=subject_instance,
workflow_instance_lineage=workflow_instance_lineage,
workflow_step_instance_lineage=workflow_step_instance_lineage,
container_instance_lineage=container_instance_lineage,
content_instance_lineage=content_instance_lineage,
equipment_instance_lineage=equipment_instance_lineage,
data_instance_lineage=data_instance_lineage,
actor_instance_lineage=actor_instance_lineage,
action_instance_lineage=action_instance_lineage,
health_event_instance_lineage=health_event_instance_lineage,
file_instance_lineage=file_instance_lineage,
file_set_instance_lineage=file_set_instance_lineage,
file_reference_instance_lineage=file_reference_instance_lineage,
subject_instance_lineage=subject_instance_lineage,
audit_log=audit_log,
)
Base = SimpleNamespace(classes=_COMPAT_BASE_CLASSES, metadata=TapDBBase.metadata)
class _TransactionContext:
"""Transaction context manager."""
def __init__(self, session: Session):
self.session = session
self.logger = logging.getLogger(__name__ + "._TransactionContext")
def __enter__(self) -> Session:
return self.session
def __exit__(self, exc_type, exc_val, exc_tb) -> bool:
if exc_type is not None:
self.logger.warning(
"Transaction rollback due to: %s: %s", exc_type.__name__, exc_val
)
self.session.rollback()
else:
try:
self.session.commit()
except Exception as exc:
self.logger.error("Commit failed, rolling back: %s", exc)
self.session.rollback()
raise
return False
class BLOOMdb3:
def __init__(
self,
app_username: str = "bloomdborm",
echo_sql: Optional[bool] = False,
pool_size: int = 5,
max_overflow: int = 10,
pool_timeout: int = 30,
pool_recycle: int = 1800,
):
self.logger = logging.getLogger(__name__ + ".BLOOMdb3")
self.app_username = app_username
runtime_ctx = apply_runtime_environment(get_settings())
self.domain_code = runtime_ctx.domain_code
self.owner_repo_name = runtime_ctx.owner_repo_name
# Best-effort attribution for TapDB-style DB metrics.
# (The request middleware sets path/method; the DB adapter tags username.)
try:
db_username_var.set(app_username)
except Exception:
pass
cfg = get_tapdb_db_config()
engine_type = cfg.get("engine_type", "local")
host = cfg["host"]
port = cfg["port"]
region = cfg.get("region", "us-west-2")
iam_auth = str(cfg.get("iam_auth", "true")).lower() in ("true", "1", "yes")
self._conn = TAPDBConnection(
db_hostname=f"{host}:{port}",
db_hostaddr=cfg.get("hostaddr") or None,
db_user=cfg["user"],
db_pass=cfg.get("password") or "",
db_name=cfg["database"],
schema_name=cfg["schema_name"],
app_username=app_username,
echo_sql=bool(echo_sql),
pool_size=pool_size,
max_overflow=max_overflow,
pool_timeout=pool_timeout,
pool_recycle=pool_recycle,
engine_type="aurora" if engine_type == "aurora" else "local",
region=region,
iam_auth=iam_auth,
domain_code=self.domain_code,
owner_repo_name=self.owner_repo_name,
)
self.engine = self._conn.engine
# Preserve the long-standing BLOOM ORM contract used across API/domain code.
self.Base = Base
# Install TapDB-style per-query metrics once per engine.
try:
maybe_install_engine_metrics(self.engine, env_name="target")
except Exception:
# Metrics are best-effort; never block DB init.
pass
self._Session = self._conn._Session
self.session = self._conn.get_session()
self._set_session_username(self.session)
def _set_session_username(self, session: Session) -> None:
"""Set audit username for the current session."""
try:
session.execute(
text("SET session.current_username = :username"),
{"username": self.app_username},
)
except Exception as exc:
self.logger.warning("Could not set session username: %s", exc)
def __enter__(self) -> "BLOOMdb3":
return self
def __exit__(self, exc_type, exc_val, exc_tb) -> bool:
if exc_type is not None:
self.session.rollback()
self.close()
return False
def transaction(self):
return _TransactionContext(self.session)
def new_session(self) -> Session:
session = self._conn.get_session()
self._set_session_username(session)
return session
def close(self) -> None:
if self.session:
try:
self.session.close()
except Exception as exc:
self.logger.warning("Error closing session: %s", exc)
self._conn.close()
__all__ = [
"Base",
"bloom_core",
"tapdb_core",
"BLOOMdb3",
"generic_template",
"generic_instance",
"generic_instance_lineage",
"workflow_template",
"workflow_step_template",
"container_template",
"content_template",
"equipment_template",
"data_template",
"actor_template",
"action_template",
"health_event_template",
"file_template",
"subject_template",
"workflow_instance",
"workflow_step_instance",
"container_instance",
"content_instance",
"equipment_instance",
"data_instance",
"actor_instance",
"action_instance",
"health_event_instance",
"file_instance",
"subject_instance",
"workflow_instance_lineage",
"workflow_step_instance_lineage",
"container_instance_lineage",
"content_instance_lineage",
"equipment_instance_lineage",
"data_instance_lineage",
"actor_instance_lineage",
"action_instance_lineage",
"health_event_instance_lineage",
"file_instance_lineage",
"subject_instance_lineage",
"file_set_template",
"file_reference_template",
"file_set_instance",
"file_reference_instance",
"file_set_instance_lineage",
"file_reference_instance_lineage",
"get_parent_lineages",
"get_child_lineages",
"audit_log",
]

Xet Storage Details

Size:
12.8 kB
·
Xet hash:
15fa45616307bf457b1e8d1a4cb239fe7c614c964d5bab54649f4b0ee2a710a5

Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.