opencloning-db 1.4.0__py3-none-any.whl

opencloning_db/__init__.py

@@ -0,0 +1,3 @@
+"""opencloning_db package."""
+
+"""OpenCloning DB package namespace."""

opencloning_db/api.py

@@ -0,0 +1,60 @@
+"""
+OpenCloning API - main FastAPI application.
+"""
+
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi_pagination import add_pagination
+import os
+from starlette.types import ASGIApp
+
+from opencloning.app_settings import settings as opencloning_settings
+from opencloning_db.config import parse_bool
+from opencloning_db.routers import (
+    auth,
+    lines,
+    primers,
+    sequence_samples,
+    sequences,
+    template_sequences,
+    tags,
+    test_tools,
+    workspaces,
+)
+
+
+def create_fastapi_app() -> FastAPI:
+    app = FastAPI(title='OpenCloningDB API')
+
+    app.include_router(auth.router)
+    app.include_router(workspaces.router)
+    app.include_router(tags.router)
+    app.include_router(primers.router)
+    app.include_router(sequences.router)
+    app.include_router(template_sequences.router)
+    app.include_router(lines.router)
+    app.include_router(sequence_samples.router)
+    if parse_bool(os.getenv('OPENCLONING_TESTING', False)):
+        app.include_router(test_tools.router)
+
+    # Register routes first so Page[...] endpoints get pagination_ctx.
+    add_pagination(app)
+    return app
+
+
+def wrap_with_cors(app: ASGIApp) -> ASGIApp:
+    return CORSMiddleware(
+        app,
+        allow_origins=opencloning_settings.ALLOWED_ORIGINS,
+        allow_credentials=True,
+        allow_methods=['*'],
+        allow_headers=['*'],
+    )
+
+
+def create_app() -> ASGIApp:
+    return wrap_with_cors(create_fastapi_app())
+
+
+fastapi_app = create_fastapi_app()
+app = wrap_with_cors(fastapi_app)

opencloning_db/apimodels.py

@@ -0,0 +1,335 @@
+"""Shared Pydantic request/response models for the API."""
+
+from datetime import datetime
+
+from pydantic import BaseModel, ConfigDict, EmailStr, Field, field_validator
+
+import opencloning_linkml.datamodel.models as opencloning_models
+from opencloning_db.models import BaseSequence, SequenceType, Sequence, Primer, Line, SequenceInLine
+
+
+class ApiModel(BaseModel):
+    """Reject unknown JSON keys on all API request/response models in this module."""
+
+    model_config = ConfigDict(extra='forbid')
+
+
+# --- Auth (OAuth2 password + JWT) ---
+class Token(ApiModel):
+    access_token: str
+    token_type: str = 'bearer'
+
+
+class UserPublic(ApiModel):
+    id: int
+    email: str
+    display_name: str | None
+    is_instance_admin: bool
+
+
+class UserRef(ApiModel):
+    """Minimal user reference for embedding in resource responses."""
+
+    id: int
+    display_name: str | None
+
+
+class WorkspaceRef(ApiModel):
+    id: int
+    name: str
+    role: str
+
+
+class WorkspaceCreate(ApiModel):
+    name: str = Field(min_length=1)
+
+
+class WorkspaceRename(ApiModel):
+    name: str = Field(min_length=1)
+
+
+class RegisterBody(ApiModel):
+    email: EmailStr
+    password: str = Field(min_length=1)
+    display_name: str | None = None
+
+
+# --- Sequence sample ---
+class SequenceSampleCreate(ApiModel):
+    uid: str
+    sequence_id: int
+
+
+class SequenceSampleUpdate(ApiModel):
+    sequence_id: int
+
+
+class SequenceSampleRead(ApiModel):
+    id: int
+    uid: str
+    sequence_id: int
+
+
+class SequenceSampleCreated(ApiModel):
+    id: int
+    uid: str
+
+
+# --- Tags ---
+class TagCreate(ApiModel):
+    name: str = Field(min_length=1)
+
+    @field_validator('name', mode='before')
+    @classmethod
+    def strip_tag_name(cls, v: object) -> object:
+        # We do it before to strip before counting the length of the string
+        if isinstance(v, str):
+            return v.strip()
+        return v
+
+
+class TagRead(ApiModel):
+    id: int
+    name: str
+
+
+class EntityTagAttach(ApiModel):
+    tag_id: int
+
+
+# --- Entity refs ---
+class InputEntityRef(ApiModel):
+    id: int
+    type: str
+    name: str | None
+
+
+class SequencingFileRef(ApiModel):
+    id: int
+    original_name: str
+
+
+# --- Common responses ---
+class IdResponse(ApiModel):
+    id: int
+
+
+class RemovedResponse(ApiModel):
+    removed: int
+
+
+class DeletedResponse(ApiModel):
+    deleted: int
+    data: dict | None = None
+
+
+# --- Cloning strategy ---
+class CloningStrategyIdMapping(ApiModel):
+    localId: int
+    databaseId: int
+
+
+class CloningStrategyResponse(ApiModel):
+    id: int
+    mappings: list[CloningStrategyIdMapping]
+
+
+# --- Sequence / primer refs ---
+class SequenceRef(ApiModel):
+    id: int
+    type: str
+    name: str | None
+    sequence_type: SequenceType
+    tags: list[TagRead] = []
+    sample_uids: list[str] = []
+    seguid: str | None = None
+    created_at: datetime
+    created_by: UserRef
+
+
+class SequenceUpdate(ApiModel):
+    name: str | None = None
+    sequence_type: SequenceType | None = None
+
+
+class TemplateSequenceCreate(ApiModel):
+    name: str = Field(min_length=1)
+    sequence_type: SequenceType
+
+    @field_validator('name', mode='before')
+    @classmethod
+    def strip_name(cls, v: object) -> object:
+        if isinstance(v, str):
+            return v.strip()
+        return v
+
+
+class PrimerUpdate(ApiModel):
+    name: str | None = None
+    uid: str | None = None
+
+    @field_validator('uid', mode='before')
+    @classmethod
+    def strip_uid(cls, v: object) -> object:
+        if isinstance(v, str):
+            return v.strip()
+        return v
+
+    @field_validator('name', mode='before')
+    @classmethod
+    def strip_name(cls, v: object) -> object:
+        if isinstance(v, str):
+            stripped_name = v.strip()
+            if len(stripped_name) < 2:
+                raise ValueError('Primer name must be at least 2 characters long')
+            return stripped_name
+        return v
+
+
+class PrimerCreate(ApiModel):
+    name: str
+    uid: str | None = None
+    sequence: str = Field(min_length=2, pattern=r'^[ACGTacgt]+$')
+
+
+class PrimerBulkSubmission(ApiModel):
+    name: str
+    uid: str | None = None
+    sequence: str
+
+
+class PrimerBulkRow(PrimerBulkSubmission):
+    sequence_invalid: bool
+    name_exists: bool
+    sequence_exists: bool
+    uid_exists: bool
+    name_duplicated: bool
+    sequence_duplicated: bool
+    uid_duplicated: bool
+
+
+class PrimerRef(ApiModel):
+    id: int
+    name: str | None
+    sequence: str
+    uid: str | None = None
+    tags: list[TagRead] = []
+    created_at: datetime
+    created_by: UserRef
+
+
+class SequenceSampleWithSequence(ApiModel):
+    id: int
+    uid: str
+    sequence_id: int
+    sequence: SequenceRef
+
+
+# --- Line ---
+class SequenceInLineRef(ApiModel):
+    """Sequence in a line, including the SequenceInLine instance id."""
+
+    id: int
+    sequence: SequenceRef
+
+
+class LineRef(ApiModel):
+    id: int
+    uid: str
+    sequences_in_line: list[SequenceInLineRef]
+    parent_ids: list[int]
+    tags: list[TagRead]
+    created_at: datetime
+    created_by: UserRef
+
+
+class LineCreate(ApiModel):
+    uid: str
+    allele_ids: list[int] = []
+    plasmid_ids: list[int] = []
+    parent_ids: list[int] = []
+
+
+class LineUpdate(ApiModel):
+    uid: str | None = None
+    allele_ids: list[int] | None = None
+    plasmid_ids: list[int] | None = None
+    parent_ids: list[int] | None = None
+
+
+def _user_ref(user) -> UserRef | None:
+    if user is None:
+        return None
+    return UserRef(id=user.id, display_name=user.display_name)
+
+
+def sequence_ref(sequence: BaseSequence) -> SequenceRef:
+    return SequenceRef(
+        id=sequence.id,
+        type=sequence.type,
+        name=sequence.name,
+        sequence_type=sequence.sequence_type,
+        tags=[TagRead(id=t.id, name=t.name) for t in sequence.tags],
+        sample_uids=sequence.sample_uids,
+        seguid=sequence.seguid if isinstance(sequence, Sequence) else None,
+        created_at=sequence.created_at,
+        created_by=_user_ref(sequence.created_by),
+    )
+
+
+def primer_ref(primer: Primer) -> PrimerRef:
+    return PrimerRef(
+        id=primer.id,
+        name=primer.name,
+        sequence=primer.sequence,
+        uid=primer.uid,
+        tags=[TagRead(id=t.id, name=t.name) for t in primer.tags],
+        created_at=primer.created_at,
+        created_by=_user_ref(primer.created_by),
+    )
+
+
+def sequence_in_line_ref(sil: SequenceInLine) -> SequenceInLineRef:
+    """Build a SequenceInLineRef from a SequenceInLine ORM instance."""
+    seq = sil.sequence
+    return SequenceInLineRef(
+        id=sil.id,
+        sequence=sequence_ref(seq),
+    )
+
+
+def line_ref(line: Line) -> LineRef:
+    return LineRef(
+        id=line.id,
+        uid=line.uid,
+        sequences_in_line=[sequence_in_line_ref(sil) for sil in line.sequences_in_line],
+        parent_ids=line.parent_ids,
+        tags=[TagRead(id=tag.id, name=tag.name) for tag in line.tags],
+        created_at=line.created_at,
+        created_by=_user_ref(line.created_by),
+    )
+
+
+class SequenceSearchResult(ApiModel):
+    sequence_ref: SequenceRef
+    sequence: opencloning_models.TextFileSequence
+    shift: int = 0
+    reverse_complemented: bool = False
+
+
+class SequenceValidationRow(ApiModel):
+    file_name: str
+    reading_error: bool
+
+    name: str | None = None
+    length: int | None = None
+    circular: bool | None = None
+    seguid: str | None = None
+    circularised_seguid: str | None = None
+
+    sequence_exists: bool | None = None
+    sequence_circularised_exists: bool | None = None
+    name_exists: bool | None = None
+
+    duplicated_seguid: bool | None = None
+    duplicated_name: bool | None = None

opencloning_db/auth/__init__.py

@@ -0,0 +1 @@
+"""Authentication helpers (password hashing, JWT)."""

opencloning_db/auth/security.py

@@ -0,0 +1,39 @@
+"""Password hashing (pwdlib) and JWT access tokens (PyJWT)."""
+
+from datetime import datetime, timedelta, timezone
+from typing import Any
+
+import jwt
+from pwdlib import PasswordHash
+
+from opencloning_db.config import Config
+
+password_hasher = PasswordHash.recommended()
+
+
+def get_password_hash(password: str) -> str:
+    return password_hasher.hash(password)
+
+
+def verify_password(plain_password: str, hashed_password: str) -> bool:
+    return password_hasher.verify(plain_password, hashed_password)
+
+
+def create_access_token(data: dict[str, Any], config: Config, expires_delta: timedelta) -> str:
+    to_encode = data.copy()
+    expire = datetime.now(timezone.utc) + expires_delta
+    to_encode.update({'exp': expire})
+    encoded_jwt = jwt.encode(
+        to_encode,
+        config.jwt_secret,
+        algorithm=config.jwt_algorithm,
+    )
+    return encoded_jwt
+
+
+def decode_access_token(token: str, config: Config) -> dict[str, Any]:
+    return jwt.decode(
+        token,
+        config.jwt_secret,
+        algorithms=[config.jwt_algorithm],
+    )

opencloning_db/combined.py

@@ -0,0 +1,28 @@
+"""Parent application that serves OpenCloning and opencloning-db under separate roots."""
+
+from fastapi import FastAPI
+
+from opencloning.main import create_app as create_cloning_app
+
+from opencloning_db.api import create_app as create_db_app
+
+
+app = FastAPI(
+    title='OpenCloning Combined API',
+    docs_url=None,
+    redoc_url=None,
+    openapi_url=None,
+)
+
+app.mount('/cloning', create_cloning_app())
+app.mount('/db', create_db_app())
+
+
+@app.get('/')
+async def root() -> dict[str, str]:
+    return {
+        'cloning': '/cloning',
+        'cloning_docs': '/cloning/docs',
+        'db': '/db',
+        'db_docs': '/db/docs',
+    }

opencloning_db/config.py

@@ -0,0 +1,92 @@
+"""
+Application configuration.
+
+Runtime config is loaded lazily from environment variables via ``get_config()``.
+Tests and other callers can still instantiate ``Config`` directly.
+"""
+
+import os
+
+from pydantic import BaseModel, Field, field_validator
+from sqlalchemy.engine import make_url
+
+_ENV_TO_FIELD = {
+    'OPENCLONING_DATABASE_URL': 'database_url',
+    'OPENCLONING_SEQUENCE_FILES_DIR': 'sequence_files_dir',
+    'OPENCLONING_SEQUENCING_FILES_DIR': 'sequencing_files_dir',
+    'OPENCLONING_JWT_SECRET': 'jwt_secret',
+}
+
+
+def parse_bool(value: str | bool) -> bool:
+    return value in {'1', 'TRUE', 'true', 'True', True}
+
+
+def _load_config_from_env() -> 'Config':
+    missing_vars = [env_name for env_name in _ENV_TO_FIELD if not os.environ.get(env_name)]
+    if missing_vars:
+        missing = ', '.join(missing_vars)
+        raise RuntimeError(
+            'Missing required OpenCloning environment variables: ' f'{missing}. For local development load .env.dev'
+        )
+
+    return Config(
+        database_url=os.environ['OPENCLONING_DATABASE_URL'],
+        sequence_files_dir=os.environ['OPENCLONING_SEQUENCE_FILES_DIR'],
+        sequencing_files_dir=os.environ['OPENCLONING_SEQUENCING_FILES_DIR'],
+        jwt_secret=os.environ['OPENCLONING_JWT_SECRET'],
+    )
+
+
+class Config(BaseModel):
+    """OpenCloning database configuration."""
+
+    @field_validator('database_url')
+    @classmethod
+    def _validate_database_url(cls, value: str) -> str:
+        url = make_url(value)
+        if url.get_backend_name() != 'postgresql':
+            raise ValueError('Only PostgreSQL database URLs are supported.')
+        if url.drivername != 'postgresql+psycopg':
+            raise ValueError(
+                'Only PostgreSQL database URLs using the psycopg driver are supported ' '(postgresql+psycopg://...).'
+            )
+        return value
+
+    database_url: str = Field(
+        description='SQLAlchemy PostgreSQL URL using the psycopg (v3) driver (postgresql+psycopg://...)',
+    )
+    sequence_files_dir: str = Field(
+        description='Directory for storing sequence GenBank files',
+    )
+    sequencing_files_dir: str = Field(
+        description='Directory for storing uploaded sequencing files (ab1, fasta, etc.)',
+    )
+    jwt_secret: str = Field(
+        description='HS256 signing key for JWT access tokens',
+    )
+    jwt_algorithm: str = Field(default='HS256', description='JWT signing algorithm')
+    access_token_expire_minutes: int = Field(
+        default=60,
+        ge=1,
+        description='Access token lifetime in minutes',
+    )
+
+
+config: Config | None = None
+
+
+def _peek_config() -> Config | None:
+    return config
+
+
+def get_config() -> Config:
+    global config
+    if config is None:
+        config = _load_config_from_env()
+    return config
+
+
+def set_config(new_config: Config | None) -> None:
+    global config
+    config = new_config

opencloning_db/context.py

@@ -0,0 +1,15 @@
+"""Lightweight value objects shared between the auth, persistence, and model layers."""
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from opencloning_db.models import User
+
+
+@dataclass(frozen=True, slots=True)
+class WriteContext:
+    """Identity for any write/create operation: who is acting, in which workspace."""
+
+    user: 'User'
+    workspace_id: int