biocompute 0.1.0__tar.gz

biocompute-0.1.0/.gitignore

@@ -0,0 +1,237 @@
+# Byte-compiled / optimized / DLL files
+controller/vision/eval
+controller/vision/models/
+controller/vision/datasets/
+easyeda-converter
+.env
+venv
+env
+_tmp_pbr_mesh.ply
+_tmp_pbr_mesh.ply
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be added to the global gitignore or merged into this project gitignore.  For a PyCharm
+#  project, it is recommended to ignore all files in the .idea directory except workspace.xml and tasks.xml.
+.idea/
+*.iws
+*.iml
+*.ipr
+
+# Visual Studio Code
+.vscode/
+
+# macOS
+.DS_Store
+.AppleDouble
+.LSOverride
+
+# Media files
+*.mp4
+*.avi
+*.mkv
+*.mov
+*.wmv
+*.flv
+*.webm
+*.m4v
+*.3gp
+*.mp3
+*.wav
+*.flac
+*.aac
+*.ogg
+*.wma
+*.m4a
+*.jpg
+*.jpeg
+*.gif
+*.bmp
+*.tiff
+*.webp
+*.svg
+*.ico
+
+# Temporary files
+*.tmp
+*.temp
+*~
+
+# Node.js / JavaScript / TypeScript
+node_modules/
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+.pnpm-debug.log*
+.npm
+.env
+.env.development.local
+.env.test.local
+.env.production.local
+.env.local
+*.tsbuildinfo
+.next
+.nuxt
+.vuepress/dist
+.docusaurus
+.serverless/
+.fusebox/
+.dynamodb/
+.tern-port
+dist/
+coverage/
+runs/
+
+# PlatformIO
+.pio/

biocompute-0.1.0/PKG-INFO

@@ -0,0 +1,118 @@
+Metadata-Version: 2.4
+Name: biocompute
+Version: 0.1.0
+Summary: London Biocompute client library
+Author: London Biocompute
+License-Expression: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.12
+Requires-Dist: httpx>=0.27
+Description-Content-Type: text/markdown
+
+# biocompute
+
+London Biocompute client library.
+
+## Install
+
+```bash
+pip install biocompute
+```
+
+## Usage
+
+```python
+from biocompute import Competition, wells, red_dye, green_dye, blue_dye
+import numpy as np
+
+with Competition(api_key="sk_...", base_url="https://...") as comp:
+
+    # Experiments are just functions
+    def measure_color(well, r, g, b):
+        well.fill(vol=r, reagent=red_dye)
+        well.fill(vol=g, reagent=green_dye)
+        well.fill(vol=b, reagent=blue_dye)
+        well.mix()
+        well.image()
+
+    # Explore: grid search
+    n_wells = 25
+    explore = np.linspace([10, 10, 10], [100, 100, 100], num=n_wells)
+
+    for well, (r, g, b) in zip(wells(count=n_wells), explore):
+        measure_color(well, r, g, b)
+
+    results = comp.submit()
+
+    # Find best well
+    best_idx = max(range(len(results.wells)), key=lambda i: results.wells[i].score or 0)
+    best_params = explore[best_idx]
+
+with Competition(api_key="sk_...", base_url="https://...") as comp:
+
+    # Exploit: random samples around best hit
+    exploit = np.random.normal(best_params, scale=5, size=(n_wells, 3)).clip(0, 200)
+
+    for well, (r, g, b) in zip(wells(count=n_wells), exploit):
+        measure_color(well, r, g, b)
+
+    results = comp.submit()
+```
+
+`wells(count=n)` gives you `n` wells. Pair with any sampling strategy via `zip`.
+
+Use `numpy`, `scipy.stats.qmc`, `pyDOE`, Ax, or any ML model to generate parameter arrays. The system doesn't care — it just sees wells and function calls.
+
+## API
+
+### `Competition(api_key, *, challenge_id="default", base_url, timeout=300.0)`
+
+Creates a competition session. Use as a context manager to ensure cleanup.
+
+- `submit()` — serialize recorded ops, POST to server, poll for results
+- `target()` — get the target image URL for this challenge
+- `leaderboard()` — get the public leaderboard
+- `close()` — release resources (called automatically by context manager)
+
+### `wells(count=96)`
+
+Generator that yields `Well` objects. Must be called after creating a `Competition`.
+
+### `Well`
+
+- `fill(vol, reagent)` — fill with a volume (microliters) of reagent
+- `mix()` — mix well contents
+- `image()` — capture an image of the well
+
+All methods return `self` for chaining: `well.fill(vol=50.0, reagent=red_dye).mix().image()`
+
+### Reagents
+
+Built-in: `red_dye`, `green_dye`, `blue_dye`, `water`
+
+Custom: `Reagent("my_reagent")`
+
+## Build & Publish
+
+```bash
+cd biocompute
+
+# Install dev dependencies
+uv sync
+
+# Run tests
+uv run pytest
+
+# Lint & type check
+uv run ruff check .
+uv run mypy src/biocompute
+
+# Build (leakage check runs automatically)
+uv run python -m build
+
+# Manual leakage check
+python check_leakage.py
+```
+
+The build includes an automatic leakage check (`hatch_build.py`) that scans for references to private internal modules and aborts if any are found.

biocompute-0.1.0/README.md

@@ -0,0 +1,106 @@
+# biocompute
+
+London Biocompute client library.
+
+## Install
+
+```bash
+pip install biocompute
+```
+
+## Usage
+
+```python
+from biocompute import Competition, wells, red_dye, green_dye, blue_dye
+import numpy as np
+
+with Competition(api_key="sk_...", base_url="https://...") as comp:
+
+    # Experiments are just functions
+    def measure_color(well, r, g, b):
+        well.fill(vol=r, reagent=red_dye)
+        well.fill(vol=g, reagent=green_dye)
+        well.fill(vol=b, reagent=blue_dye)
+        well.mix()
+        well.image()
+
+    # Explore: grid search
+    n_wells = 25
+    explore = np.linspace([10, 10, 10], [100, 100, 100], num=n_wells)
+
+    for well, (r, g, b) in zip(wells(count=n_wells), explore):
+        measure_color(well, r, g, b)
+
+    results = comp.submit()
+
+    # Find best well
+    best_idx = max(range(len(results.wells)), key=lambda i: results.wells[i].score or 0)
+    best_params = explore[best_idx]
+
+with Competition(api_key="sk_...", base_url="https://...") as comp:
+
+    # Exploit: random samples around best hit
+    exploit = np.random.normal(best_params, scale=5, size=(n_wells, 3)).clip(0, 200)
+
+    for well, (r, g, b) in zip(wells(count=n_wells), exploit):
+        measure_color(well, r, g, b)
+
+    results = comp.submit()
+```
+
+`wells(count=n)` gives you `n` wells. Pair with any sampling strategy via `zip`.
+
+Use `numpy`, `scipy.stats.qmc`, `pyDOE`, Ax, or any ML model to generate parameter arrays. The system doesn't care — it just sees wells and function calls.
+
+## API
+
+### `Competition(api_key, *, challenge_id="default", base_url, timeout=300.0)`
+
+Creates a competition session. Use as a context manager to ensure cleanup.
+
+- `submit()` — serialize recorded ops, POST to server, poll for results
+- `target()` — get the target image URL for this challenge
+- `leaderboard()` — get the public leaderboard
+- `close()` — release resources (called automatically by context manager)
+
+### `wells(count=96)`
+
+Generator that yields `Well` objects. Must be called after creating a `Competition`.
+
+### `Well`
+
+- `fill(vol, reagent)` — fill with a volume (microliters) of reagent
+- `mix()` — mix well contents
+- `image()` — capture an image of the well
+
+All methods return `self` for chaining: `well.fill(vol=50.0, reagent=red_dye).mix().image()`
+
+### Reagents
+
+Built-in: `red_dye`, `green_dye`, `blue_dye`, `water`
+
+Custom: `Reagent("my_reagent")`
+
+## Build & Publish
+
+```bash
+cd biocompute
+
+# Install dev dependencies
+uv sync
+
+# Run tests
+uv run pytest
+
+# Lint & type check
+uv run ruff check .
+uv run mypy src/biocompute
+
+# Build (leakage check runs automatically)
+uv run python -m build
+
+# Manual leakage check
+python check_leakage.py
+```
+
+The build includes an automatic leakage check (`hatch_build.py`) that scans for references to private internal modules and aborts if any are found.

biocompute-0.1.0/_leakage.py

@@ -0,0 +1,61 @@
+"""Leakage detection for the biocompute package.
+
+Scans source files for references to private internal modules
+(controller.*, compiler types, hardware details) that should
+never ship in the public package.
+
+Used by:
+- hatch_build.py (build hook, runs automatically on build)
+- check_leakage.py (CLI, for manual checks)
+"""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+# Patterns that indicate leakage of private internals
+FORBIDDEN = [
+    (r"\bfrom\s+controller\b", "import from controller (private)"),
+    (r"\bimport\s+controller\b", "import of controller (private)"),
+    (r"\bUOp\b", "reference to internal UOp type"),
+    (r"\bSourceLocation\b", "reference to internal SourceLocation"),
+    (r"\bcompile_protocol\b", "reference to compile_protocol"),
+    (r"\bCodeGenerator\b", "reference to internal CodeGenerator"),
+    (r"\bDependencyDAG\b", "reference to internal DependencyDAG"),
+    (r"\bAssignmentPlan\b", "reference to internal AssignmentPlan"),
+    (r"\bWorkcellSpec\b", "reference to internal WorkcellSpec"),
+    (r"\bDeviceSpec\b", "reference to internal DeviceSpec"),
+    (r"sk_[a-zA-Z0-9]{20,}", "possible API key literal"),
+    (r"/Users/\w+/", "absolute local path"),
+]
+
+SKIP_FILES = {"check_leakage.py", "conftest.py", "_leakage.py", "hatch_build.py"}
+
+
+def scan_file(path: Path, relative_to: Path | None = None) -> list[str]:
+    """Scan a single Python file for forbidden patterns.
+
+    Returns a list of human-readable hit descriptions.
+    """
+    if path.name in SKIP_FILES:
+        return []
+    text = path.read_text()
+    hits: list[str] = []
+    display = str(path.relative_to(relative_to)) if relative_to else str(path)
+    for lineno, line in enumerate(text.splitlines(), 1):
+        stripped = line.lstrip()
+        if stripped.startswith("#"):
+            continue
+        for pattern, reason in FORBIDDEN:
+            if re.search(pattern, line):
+                hits.append(f"  {display}:{lineno}: {reason}\n    {line.strip()}")
+    return hits
+
+
+def scan_source(src_dir: Path, relative_to: Path | None = None) -> list[str]:
+    """Scan all Python files under a directory."""
+    hits: list[str] = []
+    for py in sorted(src_dir.rglob("*.py")):
+        hits.extend(scan_file(py, relative_to=relative_to))
+    return hits

biocompute-0.1.0/check_leakage.py

@@ -0,0 +1,38 @@
+#!/usr/bin/env python3
+"""Manual leakage check CLI.
+
+The same check runs automatically during `hatch build` / `python -m build`
+via the build hook in hatch_build.py. This script is for quick manual runs.
+
+Usage:
+    python check_leakage.py
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+# Import from project root (not shipped inside the package)
+sys.path.insert(0, str(Path(__file__).parent))
+
+from _leakage import scan_source  # noqa: E402
+
+ROOT = Path(__file__).parent
+SRC = ROOT / "src" / "biocompute"
+
+
+def main() -> int:
+    print("Scanning source files...")
+    hits = scan_source(SRC, relative_to=ROOT)
+    if hits:
+        print(f"\nFOUND {len(hits)} leakage(s):\n")
+        print("\n".join(hits))
+        print("\nFAILED: Fix leakage before publishing.")
+        return 1
+    print("PASSED: No leakage detected.")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

biocompute-0.1.0/hatch_build.py

@@ -0,0 +1,34 @@
+"""Hatchling build hook that runs leakage detection before building.
+
+Automatically invoked by hatchling during `python -m build` or
+`hatch build`. Aborts the build if any private internal references
+are found in the source.
+"""
+
+from __future__ import annotations
+
+import importlib.util
+from pathlib import Path
+from typing import Any
+
+from hatchling.builders.hooks.plugin.interface import BuildHookInterface
+
+# Load _leakage.py directly to avoid importing the full biocompute
+# package (which requires httpx, not available in the build env).
+_leakage_path = Path(__file__).parent / "_leakage.py"
+_spec = importlib.util.spec_from_file_location("_leakage", _leakage_path)
+assert _spec is not None and _spec.loader is not None
+_leakage = importlib.util.module_from_spec(_spec)
+_spec.loader.exec_module(_leakage)
+
+
+class LeakageCheckHook(BuildHookInterface):
+    PLUGIN_NAME = "leakage-check"
+
+    def initialize(self, version: str, build_data: dict[str, Any]) -> None:
+        src = Path(__file__).parent / "src" / "biocompute"
+        hits: list[str] = _leakage.scan_source(src, relative_to=Path(__file__).parent)  # type: ignore[attr-defined]
+
+        if hits:
+            msg = f"Leakage check FAILED — {len(hits)} issue(s) found:\n" + "\n".join(hits)
+            raise RuntimeError(msg)

biocompute-0.1.0/pyproject.toml

@@ -0,0 +1,45 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "biocompute"
+version = "0.1.0"
+description = "London Biocompute client library"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.12"
+authors = [
+    { name = "London Biocompute" },
+]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.12",
+]
+dependencies = [
+    "httpx>=0.27",
+]
+
+[dependency-groups]
+dev = [
+    "mypy>=1.18",
+    "pytest>=9.0",
+    "pytest-httpx>=0.35",
+    "ruff>=0.14",
+]
+
+[tool.hatch.build.hooks.custom]
+
+[tool.mypy]
+strict = true
+
+[tool.ruff]
+line-length = 120
+target-version = "py312"
+
+[tool.ruff.lint]
+select = ["F", "B", "I"]
+ignore = ["E402", "E501", "E701", "B007"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

biocompute-0.1.0/src/biocompute/__init__.py

@@ -0,0 +1,22 @@
+"""biocompute - London Biocompute client library."""
+
+from biocompute._version import __version__
+from biocompute.competition import Competition, SubmissionResult, WellResult
+from biocompute.exceptions import BiocomputeError
+from biocompute.reagent import Reagent, blue_dye, green_dye, red_dye, water
+from biocompute.well import Well, wells
+
+__all__ = [
+    "__version__",
+    "Competition",
+    "SubmissionResult",
+    "WellResult",
+    "Well",
+    "wells",
+    "Reagent",
+    "red_dye",
+    "green_dye",
+    "blue_dye",
+    "water",
+    "BiocomputeError",
+]

biocompute-0.1.0/src/biocompute/_version.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"