opencloning-db 1.4.0__tar.gz

opencloning_db-1.4.0/.gitignore

@@ -0,0 +1,30 @@
+*.pyc
+/__pycache__
+.DS_Store
+.ipynb_checkpoints
+/.venv
+
+# Test coverage
+.coverage
+coverage.xml
+
+
+# Frontend build
+frontend/
+
+# Env secrets
+.env.secret
+
+batch_cloning_output/
+.pytest_cache/
+
+# build artifacts
+dist/
+
+bin/
+
+# dummy certs for testing
+certs/
+
+# development database
+dev_database/

opencloning_db-1.4.0/CHANGELOG.md

@@ -0,0 +1,13 @@
+# Changelog
+
+## [1.4.0](https://github.com/OpenCloning/OpenCloning_backend/compare/opencloning-db-v1.3.9...opencloning-db-v1.4.0) (2026-05-19)
+
+
+### Features
+
+* change opencloning-db docker-compose to mount file-storage ([#459](https://github.com/OpenCloning/OpenCloning_backend/issues/459)) ([e8653fd](https://github.com/OpenCloning/OpenCloning_backend/commit/e8653fd2c143018c1c232986a5258b2e38f811bc))
+* use multiple workers in prod with gunicorn ([#461](https://github.com/OpenCloning/OpenCloning_backend/issues/461)) ([b9cc010](https://github.com/OpenCloning/OpenCloning_backend/commit/b9cc01024a9bcbfe33a657064f96cc0816052104))
+
+## Changelog
+
+All notable changes to this package will be documented in this file.

opencloning_db-1.4.0/PKG-INFO

@@ -0,0 +1,91 @@
+Metadata-Version: 2.4
+Name: opencloning-db
+Version: 1.4.0
+Summary: Database for OpenCloning, a web application to generate molecular cloning strategies in json format, and share them with others.
+Project-URL: Repository, https://github.com/OpenCloning/OpenCloning_backend
+Author-email: Manuel Lera-Ramirez <manulera14@gmail.com>
+License-Expression: MIT
+Requires-Python: <4,>=3.11
+Requires-Dist: fastapi-pagination<0.16,>=0.15.10
+Requires-Dist: fastapi>=0.135.3
+Requires-Dist: gunicorn>=26.0.0
+Requires-Dist: opencloning-linkml>=1.0.0
+Requires-Dist: opencloning==1.3.9
+Requires-Dist: psycopg[binary]<4,>=3.2
+Requires-Dist: pwdlib[argon2]<0.3,>=0.2.1
+Requires-Dist: pydantic[email]>=2.7.1
+Requires-Dist: pydna>=5.5.11
+Requires-Dist: pyjwt<3,>=2.10.1
+Requires-Dist: sqlalchemy<3,>=2.0.41
+Requires-Dist: starlette>=1.0.0
+Description-Content-Type: text/markdown
+
+# opencloning-db
+
+`opencloning-db` is the database/API companion package for the OpenCloning backend. It provides the app and local data workflows used for OpenCloning database features.
+
+## Run locally
+
+From the repository root:
+
+```bash
+# Install or update workspace dependencies
+uv sync
+
+# If you are using mac, you may have to stop any local Postgres instances running on port 5432
+brew services stop postgresql
+
+# Start local Postgres with dev/test/e2e databases
+docker compose -f docker/docker-compose.postgres.yml up -d
+
+# Load required local runtime config
+source .env.dev
+
+# Seed the local baseline
+uv run opencloning-cli db seed
+
+# Run both the cloning and the database API - this what the OpenCloningDB frontend expects
+uv run uvicorn opencloning_db.combined:app --reload --reload-exclude='.venv'
+
+# Run the opencloning-db API (only database, not cloning. This is not used when running with the frontend)
+uv run uvicorn opencloning_db.api:app --reload --reload-exclude='.venv'
+```
+
+That will serve the cloning API at [http://127.0.0.1:8000/cloning](http://127.0.0.1:8000/cloning) and the database API at [http://127.0.0.1:8001/db](http://127.0.0.1:8001/db). That's what the OpenCloningDB frontend expects.
+
+## Running tests locally
+
+From the repository root:
+
+```bash
+# Install or update workspace dependencies
+uv sync
+
+# Run the tests
+uv run pytest packages/opencloning-db/tests -v -ks
+```
+
+## Frontend testing
+
+Frontend testing using the database requires reseting after tests that modify the database. You can do this by calling the `/__test/reset-db` endpoint with the `X-Test-Reset-Token` header set to `RESET-TOKEN`. That endpoint is only available if the `OPENCLONING_TESTING` environment variable is set to `1`.
+
+## Building and running the Docker image
+
+The Dockerfile is shared with the cloning app, and the build arg `APP_TARGET` determines which app to build. So you can build the image by running:
+
+```bash
+docker build -f docker/opencloning.Dockerfile --build-arg APP_TARGET=db -t manulera/opencloningbackend-db .
+```
+
+Then run it for development:
+
+```bash
+# Create the file storage directories
+mkdir -p docker/file_storage/sequence_files docker/file_storage/sequencing_files
+
+# Run the containers
+docker compose \
+    -f docker/docker-compose.postgres.yml \
+    -f docker/docker-compose.opencloning-db.yml \
+    up -d
+```

opencloning_db-1.4.0/README.md

@@ -0,0 +1,69 @@
+# opencloning-db
+
+`opencloning-db` is the database/API companion package for the OpenCloning backend. It provides the app and local data workflows used for OpenCloning database features.
+
+## Run locally
+
+From the repository root:
+
+```bash
+# Install or update workspace dependencies
+uv sync
+
+# If you are using mac, you may have to stop any local Postgres instances running on port 5432
+brew services stop postgresql
+
+# Start local Postgres with dev/test/e2e databases
+docker compose -f docker/docker-compose.postgres.yml up -d
+
+# Load required local runtime config
+source .env.dev
+
+# Seed the local baseline
+uv run opencloning-cli db seed
+
+# Run both the cloning and the database API - this what the OpenCloningDB frontend expects
+uv run uvicorn opencloning_db.combined:app --reload --reload-exclude='.venv'
+
+# Run the opencloning-db API (only database, not cloning. This is not used when running with the frontend)
+uv run uvicorn opencloning_db.api:app --reload --reload-exclude='.venv'
+```
+
+That will serve the cloning API at [http://127.0.0.1:8000/cloning](http://127.0.0.1:8000/cloning) and the database API at [http://127.0.0.1:8001/db](http://127.0.0.1:8001/db). That's what the OpenCloningDB frontend expects.
+
+## Running tests locally
+
+From the repository root:
+
+```bash
+# Install or update workspace dependencies
+uv sync
+
+# Run the tests
+uv run pytest packages/opencloning-db/tests -v -ks
+```
+
+## Frontend testing
+
+Frontend testing using the database requires reseting after tests that modify the database. You can do this by calling the `/__test/reset-db` endpoint with the `X-Test-Reset-Token` header set to `RESET-TOKEN`. That endpoint is only available if the `OPENCLONING_TESTING` environment variable is set to `1`.
+
+## Building and running the Docker image
+
+The Dockerfile is shared with the cloning app, and the build arg `APP_TARGET` determines which app to build. So you can build the image by running:
+
+```bash
+docker build -f docker/opencloning.Dockerfile --build-arg APP_TARGET=db -t manulera/opencloningbackend-db .
+```
+
+Then run it for development:
+
+```bash
+# Create the file storage directories
+mkdir -p docker/file_storage/sequence_files docker/file_storage/sequencing_files
+
+# Run the containers
+docker compose \
+    -f docker/docker-compose.postgres.yml \
+    -f docker/docker-compose.opencloning-db.yml \
+    up -d
+```

opencloning_db-1.4.0/pyproject.toml

@@ -0,0 +1,48 @@
+[project]
+name = "opencloning-db"
+version = "1.4.0"
+description = "Database for OpenCloning, a web application to generate molecular cloning strategies in json format, and share them with others."
+readme = "README.md"
+license = "MIT"
+authors = [
+    { name = "Manuel Lera-Ramirez", email = "manulera14@gmail.com" },
+]
+requires-python = ">=3.11,<4"
+dependencies = [
+    "opencloning==1.3.9",  # x-release-please-version
+    "fastapi>=0.135.3",
+    "fastapi-pagination>=0.15.10,<0.16",
+    "opencloning-linkml>=1.0.0",
+    "pydantic[email]>=2.7.1",
+    "psycopg[binary]>=3.2,<4",
+    "sqlalchemy>=2.0.41,<3",
+    "PyJWT>=2.10.1,<3",
+    "pwdlib[argon2]>=0.2.1,<0.3",
+    "pydna>=5.5.11",
+    "starlette>=1.0.0",
+    "gunicorn>=26.0.0",
+]
+
+[project.urls]
+Repository = "https://github.com/OpenCloning/OpenCloning_backend"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/opencloning_db"]
+
+[tool.uv.sources]
+opencloning = { workspace = true }
+
+[tool.black]
+skip-string-normalization = true
+line-length = 119
+
+[tool.deptry]
+known_first_party = ["opencloning_db"]
+per_rule_ignores = { DEP002 = ["psycopg", "gunicorn"] }
+
+[tool.hatch.metadata]
+allow-direct-references = true

opencloning_db-1.4.0/src/opencloning_db/__init__.py

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

opencloning_db-1.4.0/src/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-1.4.0/src/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-1.4.0/src/opencloning_db/auth/__init__.py

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

opencloning_db-1.4.0/src/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],
+    )