data objects implemented in rust

Author: sbooeshaghi

Cargo.toml

@@ -0,0 +1,26 @@
+[package]
+name = "seqspec"
+version = "0.1.0"
+edition = "2021"
+license = "MIT"
+repository = "https://github.com/pachterlab/seqspec"
+description = "Sequencing specification tools (Rust core + PyO3 bindings)"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+[lib]
+name = "seqspec"
+crate-type = ["rlib", "cdylib"]
+
+[dependencies]
+pyo3 = { version = "0.25", optional = true, features = ["extension-module", "abi3-py312"] }
+pythonize = "0.25.0"
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+serde_yaml = "0.9"
+thiserror = "1"
+
+
+[features]
+default = []
+python-binding = ["pyo3"]          # enable PyO3 only when building Python wheels
+

pyproject.toml

@@ -1,10 +1,11 @@
 [build-system]
-requires = ["setuptools>=61.0"]
-build-backend = "setuptools.build_meta"
+requires = ["maturin>=1.9,<2.0"]
+build-backend = "maturin"
 
 [project]
 name = "seqspec"
 version = "0.4.0"
+
 description = "A tool for working with sequencing specifications"
 readme = "README.md"
 requires-python = ">=3.12"
@@ -20,6 +21,9 @@ classifiers = [
     "Programming Language :: Python :: 3.13",
     "Topic :: Scientific/Engineering :: Bio-Informatics",
     "Topic :: Utilities",
+    "Programming Language :: Rust",
+    "Programming Language :: Python :: Implementation :: CPython",
+    "Programming Language :: Python :: Implementation :: PyPy",
 ]
 dependencies = [
     "pyyaml>=6.0",
@@ -60,7 +64,7 @@ license-files = ["LICENSE"]
 include = ["seqspec", "seqspec.*"]
 
 [tool.setuptools.package-data]
-"seqspec" = ["schema/*"]
+"seqspec" = ["schema/*", "py.typed", "_core.pyi"]
 
 [tool.pytest.ini_options]
 testpaths = ["tests"]
@@ -98,4 +102,11 @@ dev = [
     "pre-commit>=4.2.0",
     "build>=1.0.0",
     "ruff>=0.9.0",
-]
+]
+
+
+[tool.maturin]
+# Build the PyO3 module named *seqspec* (matches #[pymodule] above)
+module-name = "seqspec._core"
+features = ["python-binding"]
+python-source = "."   # ship python/seqspec/* alongside the native module

seqspec/Assay.py

@@ -1,4 +1,4 @@
-from typing import List, Optional, Union
+from typing import Iterable, List, Optional, Type, Union
 
 import yaml
 from pydantic import BaseModel, Field, PrivateAttr
@@ -7,6 +7,9 @@
 from seqspec.Region import Region, RegionInput
 
 from . import __version__
+from ._core import Assay as _RustAssay
+from ._core import Read as _RustRead
+from ._core import Region as _RustRegion
 
 
 class SeqProtocol(BaseModel):
@@ -159,6 +162,60 @@ def to_libkit(self) -> LibKit:
         )
 
 
+def coerce_protocol_kit_list(value, cls: Type[BaseModel], modalities: Iterable[str]):
+    """
+    Coerce a string or list of strings/objects/dicts into a list of protocol/kit objects (or None).
+
+    Supports:
+      - "NovaSeq"                         -> [cls(protocol_id|kit_id="NovaSeq", name="NovaSeq", modality=m) for m in modalities]
+      - ["A","B"]                         -> expanded per modality
+      - [{"protocol_id": "...", ...}]     -> cls(**dict)
+      - [cls(...), "X", {...}]            -> mixed inputs
+    """
+    if value is None:
+        return None
+
+    # identify target family (protocol vs kit) by class
+    is_protocol = cls.__name__ in {"SeqProtocol", "LibProtocol"}
+    is_kit = cls.__name__ in {"SeqKit", "LibKit"}
+
+    if not (is_protocol or is_kit):
+        raise ValueError("cls must be one of: SeqProtocol, LibProtocol, SeqKit, LibKit")
+
+    def make_obj(val, modality: str):
+        if isinstance(val, cls):
+            return val
+        if isinstance(val, dict):
+            return cls(**val)
+        if isinstance(val, str):
+            if is_protocol:
+                return cls(protocol_id=val, name=val, modality=modality)
+            else:
+                return cls(kit_id=val, name=val, modality=modality)
+        raise TypeError(f"Unsupported item type for {cls.__name__}: {type(val)!r}")
+
+    if isinstance(value, str):
+        return [make_obj(value, m) for m in modalities]
+
+    if isinstance(value, list):
+        out = []
+        for item in value:
+            if isinstance(item, str):
+                out.extend(make_obj(item, m) for m in modalities)
+            else:
+                # dict or already-typed object: keep as a single item
+                # if it lacks modality, caller's responsibility (your spec usually includes it)
+                out.append(make_obj(item, next(iter(modalities), "")))
+        return out
+
+    # already a typed object (rare), wrap into list
+    if isinstance(value, cls):
+        return [value]
+
+    # last resort: pass through
+    return value
+
+
 class Assay(BaseModel):
     seqspec_version: Optional[str] = __version__
     assay_id: str
@@ -180,6 +237,9 @@ class Assay(BaseModel):
     # Not part of the public schema; populated when loading from disk.
     _spec_path: Optional[str] = PrivateAttr(default=None)
 
+    def model_post_init(self, __context) -> None:
+        self.normalize_protocols_kits()
+
     def __repr__(self) -> str:
         rds = []
         rgns = []
@@ -214,6 +274,7 @@ def print_sequence(self):
         print("\n", end="")
 
     def update_spec(self):
+        self.normalize_protocols_kits()
         for r in self.library_spec:
             r.update_attr()
 
@@ -294,6 +355,82 @@ def insert_reads(
             self.sequence_spec.insert(insert_idx, read)
             insert_idx += 1
 
+    def normalize_protocols_kits(self) -> None:
+        """Normalize str-valued protocol/kit fields into lists of objects."""
+        self.sequence_protocol = coerce_protocol_kit_list(
+            self.sequence_protocol, SeqProtocol, self.modalities
+        )
+        self.sequence_kit = coerce_protocol_kit_list(
+            self.sequence_kit, SeqKit, self.modalities
+        )
+        self.library_protocol = coerce_protocol_kit_list(
+            self.library_protocol, LibProtocol, self.modalities
+        )
+        self.library_kit = coerce_protocol_kit_list(
+            self.library_kit, LibKit, self.modalities
+        )
+
+
+class RustAssay:
+    __slots__ = ("_inner",)
+
+    def __init__(self, inner: _RustAssay) -> None:
+        object.__setattr__(self, "_inner", inner)
+
+    # generic forwarding
+    def __getattr__(self, name):
+        return getattr(self._inner, name)
+
+    def __setattr__(self, name, value):
+        if name == "_inner":
+            return object.__setattr__(self, name, value)
+        return setattr(self._inner, name, value)
+
+    # constructors
+    @classmethod
+    def from_model(cls, m: "Assay") -> "RustAssay":
+        return cls(_RustAssay.from_json(m.model_dump_json()))
+
+    def snapshot(self) -> "Assay":
+        return Assay.model_validate_json(self._inner.to_json())
+
+    # helpers: DTO outputs for downstream Python code
+    def list_modalities(self) -> List[str]:
+        return list(self._inner.list_modalities())
+
+    def get_libspec(self, modality: str) -> Region:
+        r: _RustRegion = self._inner.get_libspec(modality)
+        return Region.model_validate_json(r.to_json())
+
+    def get_seqspec(self, modality: str) -> List[Read]:
+        rlist: List[_RustRead] = self._inner.get_seqspec(modality)
+        return [Read.model_validate_json(r.to_json()) for r in rlist]
+
+    def get_read(self, read_id: str) -> Read:
+        r: _RustRead = self._inner.get_read(read_id)
+        return Read.model_validate_json(r.to_json())
+
+    def update_spec(self) -> None:
+        self._inner.update_spec()
+
+    def insert_reads(
+        self, reads: List[Read], modality: str, after: Optional[str] = None
+    ) -> None:
+        # Convert DTOs to Rust via JSON (serde builds Vec<Read>)
+        raw: List[_RustRead] = [_RustRead.from_json(r.model_dump_json()) for r in reads]
+        self._inner.insert_reads(raw, modality, after)
+
+    def insert_regions(
+        self, regions: List[Region], modality: str, after: Optional[str] = None
+    ) -> None:
+        raw: List[_RustRegion] = [
+            _RustRegion.from_json(r.model_dump_json()) for r in regions
+        ]
+        self._inner.insert_regions(raw, modality, after)
+
+    def __repr__(self) -> str:
+        return self._inner.__repr__()
+
 
 class AssayInput(BaseModel):
     """

seqspec/File.py

@@ -3,6 +3,8 @@
 
 from pydantic import BaseModel, Field
 
+from ._core import File as _RustFile
+
 __all__ = ["File"]
 
 
@@ -15,12 +17,11 @@ class File(BaseModel):
     urltype: str
     md5: str
 
+    # add an updatae_spec attr that computes the md5 for the object
+
     def __repr__(self) -> str:
         return self.file_id
 
-    def update_file_id(self, file_id: str):
-        self.file_id = file_id
-
 
 class FileInput(BaseModel):
     """
@@ -91,3 +92,50 @@ def to_file(self) -> File:
             urltype=self.urltype or "local",
             md5=self.md5 or "",
         )
+
+
+class RustFile:
+    __slots__ = ("_inner",)
+
+    def __init__(self, inner: _RustFile) -> None:
+        self._inner = inner
+
+    @classmethod
+    def new(
+        cls,
+        *,
+        file_id: str,
+        filename: str,
+        filetype: str,
+        filesize: int,
+        url: str,
+        urltype: str,
+        md5: str,
+    ) -> "RustFile":
+        return cls(
+            _RustFile(file_id, filename, filetype, int(filesize), url, urltype, md5)
+        )
+
+    def __getattr__(self, name):
+        # called only if attribute not found on Rust object itself
+        return getattr(self._inner, name)
+
+    def __setattr__(self, name, value):
+        if name == "_inner":
+            object.__setattr__(self, name, value)
+        else:
+            setattr(self._inner, name, value)
+
+    @classmethod
+    def from_model(cls, m: File) -> "RustFile":
+        return cls(_RustFile.from_json(m.model_dump_json()))
+
+    @classmethod
+    def from_input(cls, i: FileInput) -> "RustFile":
+        return cls.from_model(i.to_file())
+
+    def snapshot(self) -> File:
+        return File.model_validate_json(self._inner.to_json())
+
+    def __repr__(self) -> str:
+        return f"RustFile(file_id={self.file_id!r}, filename={self.filename!r}, size={self.filesize})"