fpbase 0.0.1__py3-none-any.whl

fpbase/__init__.py

@@ -0,0 +1,21 @@
+"""Python wrapper for FPBase API."""
+
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    __version__ = version("fpbasepy")
+except PackageNotFoundError:
+    __version__ = "uninstalled"
+__author__ = "Talley Lambert"
+__email__ = "talley.lambert@gmail.com"
+
+from . import models
+from ._fetch import FPbaseClient, get_filter, get_fluorophore, get_microscope
+
+__all__ = [
+    "FPbaseClient",
+    "get_filter",
+    "get_fluorophore",
+    "get_microscope",
+    "models",
+]

fpbase/_fetch.py

@@ -0,0 +1,161 @@
+"""Main fetching logic."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import threading
+from difflib import get_close_matches
+from functools import cached_property
+from typing import TYPE_CHECKING
+
+import requests
+
+from ._graphql import DYE_QUERY, FILTER_QUERY, MICROSCOPE_QUERY, PROTEIN_QUERY
+from .models import (
+    DyeResponse,
+    Filter,
+    FilterSpectrumResponse,
+    Fluorophore,
+    Microscope,
+    MicroscopeResponse,
+    ProteinResponse,
+)
+
+if TYPE_CHECKING:
+    from collections.abc import Mapping
+
+
+class FPbaseClient:
+    __instance: FPbaseClient | None = None
+    __lock: threading.Lock = threading.Lock()
+
+    @classmethod
+    def instance(cls) -> FPbaseClient:
+        if cls.__instance is None:
+            with cls.__lock:
+                if cls.__instance is None:  # Double-checked locking
+                    cls.__instance = cls()
+        return cls.__instance
+
+    def __init__(self, base_url: str = "https://www.fpbase.org/graphql/"):
+        self.base_url = base_url
+        self.session = requests.Session()
+        self.session.headers.update(
+            {"Content-Type": "application/json", "User-Agent": "fpbase-py"}
+        )
+        self._cache: dict[str, bytes] = {}
+
+    def get_microscope(self, id: str = "i6WL2W") -> Microscope:
+        """Get microscope by ID.
+
+        Examples
+        --------
+        >>> get_microscope("i6WL2W")
+        """
+        resp = self._send_query(MICROSCOPE_QUERY, {"id": id})
+        return MicroscopeResponse.model_validate_json(resp).data.microscope
+
+    def get_fluorophore(self, name: str) -> Fluorophore:
+        """Fetch fluorophore by name, slug, or ID.
+
+        Examples
+        --------
+        >>> get_fluorophore("mTurquoise2")
+        >>> get_fluorophore("mturquoise2")
+        """
+        _ids = self._fluorophore_ids
+        if name in _ids:  # direct hit
+            fluor_info = _ids[name]
+        else:
+            try:
+                fluor_info = _ids[name.lower()]
+            except KeyError as e:
+                if closest := get_close_matches(name, _ids, n=1, cutoff=0.5):
+                    suggest = f" Did you mean {closest[0]!r}?"
+                else:
+                    suggest = ""
+                raise ValueError(f"Fluorophore {name!r} not found.{suggest}") from e
+
+        if fluor_info["type"] == "d":
+            return self._get_dye_by_id(fluor_info["id"])
+        elif fluor_info["type"] == "p":
+            return self._get_protein_by_id(fluor_info["id"])
+        raise ValueError(f"Invalid fluorophore type {fluor_info['type']!r}")
+
+    def get_filter(self, name: str) -> Filter:
+        """Fetch filter spectrum by name."""
+        normed = _norm_name(name)
+        try:
+            filter_id = self._filter_spectrum_ids[normed]
+        except KeyError as e:
+            if closest := get_close_matches(
+                normed, self._filter_spectrum_ids, n=1, cutoff=0.5
+            ):
+                suggest = f" Did you mean {closest[0]!r}?"
+            else:
+                suggest = ""
+            raise ValueError(f"Filter {name!r} not found.{suggest}") from e
+
+        resp = self._send_query(FILTER_QUERY, {"id": int(filter_id)})
+        return FilterSpectrumResponse.model_validate_json(
+            resp
+        ).data.spectrum.ownerFilter
+
+    # -----------------------------------------------------------
+
+    def _send_query(self, query: str, variables: dict | None = None) -> bytes:
+        payload = {"query": query, "variables": variables or {}}
+        payload_str = json.dumps(payload, sort_keys=True)  # Convert to JSON string
+        # Create a hash
+        hashkey = hashlib.md5(payload_str.encode("utf-8")).hexdigest()
+        if hashkey not in self._cache:
+            data = json.dumps(payload).encode("utf-8")
+            response = self.session.post(self.base_url, data=data)
+            response.raise_for_status()
+            self._cache[hashkey] = response.content
+        return self._cache[hashkey]
+
+    @cached_property
+    def _fluorophore_ids(self) -> dict[str, dict[str, str]]:
+        """Return a lookup table of fluorophore {name: {id: ..., type: ...}}."""
+        resp = self._send_query("{ dyes { id name slug } proteins { id name slug } }")
+        data: dict[str, list[dict[str, str]]] = json.loads(resp)["data"]
+        lookup: dict[str, dict[str, str]] = {}
+        for key in ["dyes", "proteins"]:
+            for item in data[key]:
+                lookup[item["name"].lower()] = {"id": item["id"], "type": key[0]}
+                lookup[item["slug"]] = {"id": item["id"], "type": key[0]}
+                if key == "proteins":
+                    lookup[item["id"]] = {"id": item["id"], "type": key[0]}
+        return lookup
+
+    @cached_property
+    def _filter_spectrum_ids(self) -> Mapping[str, int]:
+        resp = self._send_query('{ spectra(category:"F") { id owner { name } } }')
+        data: dict = json.loads(resp)["data"]["spectra"]
+        return {_norm_name(item["owner"]["name"]): int(item["id"]) for item in data}
+
+    def _get_dye_by_id(self, id: str | int) -> Fluorophore:
+        resp = self._send_query(DYE_QUERY, {"id": int(id)})
+        return DyeResponse.model_validate_json(resp).data.dye
+
+    def _get_protein_by_id(self, id: str) -> Fluorophore:
+        resp = self._send_query(PROTEIN_QUERY, {"id": id})
+        return ProteinResponse.model_validate_json(resp).data.protein
+
+
+def _norm_name(name: str) -> str:
+    return name.lower().replace(" ", "-").replace("/", "-")
+
+
+def get_microscope(id: str = "i6WL2W") -> Microscope:
+    return FPbaseClient.instance().get_microscope(id)
+
+
+def get_fluorophore(name: str) -> Fluorophore:
+    return FPbaseClient.instance().get_fluorophore(name)
+
+
+def get_filter(name: str) -> Filter:
+    return FPbaseClient.instance().get_filter(name)

fpbase/_graphql.py

@@ -0,0 +1,74 @@
+MICROSCOPE_QUERY = """
+query getMicroscope($id: String!) {
+    microscope(id: $id) {
+        id
+        name
+        opticalConfigs {
+            name
+            filters {
+                name
+                path
+                reflects
+                spectrum { subtype data }
+            }
+            camera { name spectrum { subtype data } }
+            light { name spectrum { subtype data } }
+            laser
+        }
+    }
+}
+"""
+
+DYE_QUERY = """
+query getDye($id: Int!) {
+    dye(id: $id) {
+        name
+        id
+        exMax
+        emMax
+        extCoeff
+        qy
+        spectra { subtype data }
+    }
+}
+"""
+
+PROTEIN_QUERY = """
+query getProtein($id: String!) {
+    protein(id: $id) {
+        name
+        id
+        states {
+            id
+            name
+            exMax
+            emMax
+            emhex
+            exhex
+            extCoeff
+            qy
+            lifetime
+            spectra { subtype data }
+        }
+        defaultState {
+            id
+        }
+    }
+}
+"""
+
+FILTER_QUERY = """
+query getSpectrum($id: Int!) {
+    spectrum(id: $id) {
+        subtype
+        data
+        ownerFilter {
+            name
+            manufacturer
+            bandcenter
+            bandwidth
+            edge
+        }
+    }
+}
+"""

fpbase/models.py

@@ -0,0 +1,231 @@
+"""Main fetching logic."""
+
+from enum import Enum
+from typing import Any, Literal, Optional
+
+from pydantic import BaseModel, Field, field_validator, model_validator
+
+__all__ = [
+    "Filter",
+    "FilterPlacement",
+    "FilterSpectrum",
+    "Fluorophore",
+    "Microscope",
+    "OpticalConfig",
+    "Spectrum",
+    "SpectrumOwner",
+    "SpectrumType",
+    "State",
+]
+
+
+class SpectrumType(str, Enum):
+    """Spectrum types."""
+
+    A_2P = "A_2P"
+    BM = "BM"
+    BP = "BP"
+    BS = "BS"
+    BX = "BX"
+    EM = "EM"
+    EX = "EX"
+    LP = "LP"
+    PD = "PD"
+    QE = "QE"
+    AB = "AB"
+
+    def __str__(self) -> str:
+        """Return the string representation of the enum."""
+        return self.value
+
+    def __repr__(self) -> str:
+        """Return the repr of the enum."""
+        return repr(self.value)
+
+
+class Spectrum(BaseModel):
+    """Spectrum with data."""
+
+    subtype: SpectrumType
+    data: list[tuple[float, float]] = Field(..., repr=False)
+
+
+class Filter(BaseModel):
+    """A filter with its properties."""
+
+    name: str
+    manufacturer: str
+    bandcenter: Optional[float]
+    bandwidth: Optional[float]
+    edge: Optional[float]
+
+
+class FilterSpectrum(Spectrum):
+    """Spectrum owned by a filter."""
+
+    ownerFilter: Filter
+
+
+class SpectrumOwner(BaseModel):
+    """Something that can own a spectrum."""
+
+    name: str
+    spectrum: Spectrum
+
+
+class State(BaseModel):
+    """Fluorophore state."""
+
+    id: int
+    exMax: float  # nanometers
+    emMax: float  # nanometers
+    emhex: str = ""
+    exhex: str = ""
+    extCoeff: Optional[float] = None  # M^-1 cm^-1
+    qy: Optional[float] = None
+    spectra: list[Spectrum]
+    lifetime: Optional[float] = None  # ns
+
+    @property
+    def excitation_spectrum(self) -> Optional[Spectrum]:
+        """Return the excitation spectrum, absorption spectrum, or None."""
+        spect = next((s for s in self.spectra if s.subtype == "EX"), None)
+        if not spect:
+            spect = next((s for s in self.spectra if s.subtype == "AB"), None)
+        return spect
+
+    @property
+    def emission_spectrum(self) -> Optional[Spectrum]:
+        """Return the emission spectrum or None."""
+        return next((s for s in self.spectra if s.subtype == "EM"), None)
+
+
+class Fluorophore(BaseModel):
+    """A fluorophore with its states."""
+
+    name: str
+    id: str
+    states: list[State] = Field(default_factory=list)
+    defaultState: Optional[int] = None
+
+    @model_validator(mode="before")
+    @classmethod
+    def _v_model(cls, v: Any) -> Any:
+        if isinstance(v, dict):
+            out = dict(v)
+            if "states" not in v and "exMax" in v:
+                out["states"] = [State(**v)]
+            return out
+        return v
+
+    @field_validator("defaultState", mode="before")
+    @classmethod
+    def _v_default_state(cls, v: Any) -> int:
+        if isinstance(v, dict) and "id" in v:
+            return int(v["id"])
+        return int(v)
+
+    @property
+    def default_state(self) -> Optional[State]:
+        """Return the default state or the first state."""
+        for state in self.states:
+            if state.id == self.defaultState:
+                return state
+        return next(iter(self.states), None)
+
+
+class FilterPlacement(SpectrumOwner):
+    """A filter placed in a microscope."""
+
+    path: Literal["EX", "EM", "BS"]
+    reflects: bool = False
+
+
+class OpticalConfig(BaseModel):
+    """A collection of filters and light sources."""
+
+    name: str
+    filters: list[FilterPlacement]
+    camera: Optional[SpectrumOwner]
+    light: Optional[SpectrumOwner]
+    laser: Optional[int]
+
+
+class Microscope(BaseModel):
+    """A microscope with its optical configurations."""
+
+    id: str
+    name: str
+    opticalConfigs: list[OpticalConfig]
+
+
+class _MicroscopePayload(BaseModel):
+    microscope: Microscope
+
+
+class MicroscopeResponse(BaseModel):
+    """Response for a microscope query."""
+
+    data: _MicroscopePayload
+
+
+class _ProteinPayload(BaseModel):
+    protein: Fluorophore
+
+
+class ProteinResponse(BaseModel):
+    """Response for a protein query."""
+
+    data: _ProteinPayload
+
+
+class _DyePayload(BaseModel):
+    dye: Fluorophore
+
+
+class DyeResponse(BaseModel):
+    """Response for a dye query."""
+
+    data: _DyePayload
+
+
+class _FilterSpectrumPayload(BaseModel):
+    spectrum: FilterSpectrum
+
+
+class FilterSpectrumResponse(BaseModel):
+    """Response for a filter spectrum query."""
+
+    data: _FilterSpectrumPayload
+
+
+# WIP
+# def generate_graphql_query(model: type[BaseModel], model_name: str = "") -> str:
+#     def get_fields(model: type[BaseModel]) -> str:
+#         fields = []
+#         for name, field in model.model_fields.items():
+#             annotation = field.annotation
+
+#             if isinstance(annotation, type) and issubclass(annotation, BaseModel):
+#                 sub_fields = get_fields(annotation)
+#                 fields.append(f"{name} {{ {sub_fields} }}")
+#             elif (
+#                 get_origin(annotation) in (list, tuple)
+#                 and isinstance(type_ := get_args(annotation)[0], type)
+#                 and issubclass(type_, BaseModel)
+#             ):
+#                 sub_fields = get_fields(type_)
+#                 fields.append(f"{name} {{ {sub_fields} }}")
+#             else:
+#                 fields.append(name)
+#         return "\n".join(fields)
+
+#     fields_str = get_fields(model)
+#     model_name = model_name or model.__name__
+#     return f"""
+#     query get{model_name}($id: String!) {{
+#         {model_name.lower()}(id: $id) {{
+#             {fields_str}
+#         }}
+#     }}
+#     """

fpbase/py.typed

@@ -0,0 +1,5 @@
+You may remove this file if you don't intend to add types to your package
+
+Details at:
+
+https://mypy.readthedocs.io/en/stable/installed_packages.html#creating-pep-561-compatible-packages

fpbase-0.0.1.dist-info/METADATA

@@ -0,0 +1,197 @@
+Metadata-Version: 2.3
+Name: fpbase
+Version: 0.0.1
+Summary: Python wrapper for FPBase API
+Project-URL: homepage, https://github.com/tlambert03/fpbasepy
+Project-URL: repository, https://github.com/tlambert03/fpbasepy
+Author-email: Talley Lambert <talley.lambert@gmail.com>
+License: BSD-3-Clause
+Classifier: Development Status :: 3 - Alpha
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Requires-Dist: pydantic
+Requires-Dist: requests
+Provides-Extra: dev
+Requires-Dist: ipython; extra == 'dev'
+Requires-Dist: mypy; extra == 'dev'
+Requires-Dist: pdbpp; extra == 'dev'
+Requires-Dist: pre-commit; extra == 'dev'
+Requires-Dist: rich; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'
+Requires-Dist: types-requests; extra == 'dev'
+Provides-Extra: test
+Requires-Dist: pytest; extra == 'test'
+Requires-Dist: pytest-cov; extra == 'test'
+Description-Content-Type: text/markdown
+
+# fpbasepy
+
+[![License](https://img.shields.io/pypi/l/fpbasepy.svg?color=green)](https://github.com/tlambert03/fpbasepy/raw/main/LICENSE)
+[![PyPI](https://img.shields.io/pypi/v/fpbasepy.svg?color=green)](https://pypi.org/project/fpbasepy)
+[![Python Version](https://img.shields.io/pypi/pyversions/fpbasepy.svg?color=green)](https://python.org)
+[![CI](https://github.com/tlambert03/fpbasepy/actions/workflows/ci.yml/badge.svg)](https://github.com/tlambert03/fpbasepy/actions/workflows/ci.yml)
+[![codecov](https://codecov.io/gh/tlambert03/fpbasepy/branch/main/graph/badge.svg)](https://codecov.io/gh/tlambert03/fpbasepy)
+
+Python wrapper for FPBase.org GraphQL API.
+
+See https://www.fpbase.org/graphql for full documentation on the graphql schema and an interactive playground.
+
+This library provides simple Python access to commonly-accessed data.
+
+```python
+In [1]: from fpbase import get_fluorophore, get_microscope
+
+In [2]: print(get_fluorophore("mCherry"))
+Fluorophore(
+    name='mCherry',
+    id='ZERB6',
+    states=[
+        State(
+            id=336,
+            exMax=587.0,
+            emMax=610.0,
+            emhex='#f70000',
+            exhex='#ff4600',
+            extCoeff=72000.0,
+            qy=0.22,
+            spectra=[Spectrum(subtype='EX'), Spectrum(subtype='EM'), Spectrum(subtype='A_2P')],
+            lifetime=1.4
+        )
+    ],
+    defaultState=336
+)
+
+In [3]: print(get_fluorophore("DAPI"))
+Fluorophore(
+    name='DAPI',
+    id='15',
+    states=[
+        State(
+            id=15,
+            exMax=359.0,
+            emMax=461.0,
+            emhex='',
+            exhex='',
+            extCoeff=None,
+            qy=None,
+            spectra=[Spectrum(subtype='AB'), Spectrum(subtype='EX'), Spectrum(subtype='EM')],
+            lifetime=None
+        )
+    ],
+    defaultState=None
+)
+
+In [4]: print(get_microscope("i6WL2W"))
+Microscope(
+    id='i6WL2WdgcDMgJYtPrpZcaJ',
+    name='Example Widefield (Sedat)',
+    opticalConfigs=[
+        OpticalConfig(
+            name='Widefield Blue',
+            filters=[
+                FilterPlacement(name='Chroma ET395/25x', spectrum=Spectrum(subtype='BX'), path='EX', reflects=False),
+                FilterPlacement(name='Chroma T425lpxr', spectrum=Spectrum(subtype='LP'), path='BS', reflects=False),
+                FilterPlacement(name='Chroma ET460/50m', spectrum=Spectrum(subtype='BM'), path='EM', reflects=False)
+            ],
+            camera=SpectrumOwner(name='Andor Zyla 4.2 PLUS', spectrum=Spectrum(subtype='QE')),
+            light=SpectrumOwner(name='SOLA 395', spectrum=Spectrum(subtype='PD')),
+            laser=None
+        ),
+        OpticalConfig(
+            name='Widefield Dual FRET',
+            filters=[
+                FilterPlacement(name='Lumencor 470/24x', spectrum=Spectrum(subtype='BX'), path='EX', reflects=False),
+                FilterPlacement(name='Chroma 59022bs', spectrum=Spectrum(subtype='BS'), path='BS', reflects=False),
+                FilterPlacement(name='Semrock FF02-641/75', spectrum=Spectrum(subtype='BP'), path='EM', reflects=False)
+            ],
+            camera=SpectrumOwner(name='Andor Zyla 4.2 PLUS', spectrum=Spectrum(subtype='QE')),
+            light=SpectrumOwner(name='SOLA 395', spectrum=Spectrum(subtype='PD')),
+            laser=None
+        ),
+        OpticalConfig(
+            name='Widefield Dual Green',
+            filters=[
+                FilterPlacement(name='Lumencor 470/24x', spectrum=Spectrum(subtype='BX'), path='EX', reflects=False),
+                FilterPlacement(name='Chroma 59022bs', spectrum=Spectrum(subtype='BS'), path='BS', reflects=False),
+                FilterPlacement(name='Semrock FF03-525/50', spectrum=Spectrum(subtype='BP'), path='EM', reflects=False)
+            ],
+            camera=SpectrumOwner(name='Andor Zyla 4.2 PLUS', spectrum=Spectrum(subtype='QE')),
+            light=SpectrumOwner(name='SOLA 395', spectrum=Spectrum(subtype='PD')),
+            laser=None
+        ),
+        OpticalConfig(
+            name='Widefield Dual Red',
+            filters=[
+                FilterPlacement(name='Lumencor 575/25x', spectrum=Spectrum(subtype='BX'), path='EX', reflects=False),
+                FilterPlacement(name='Chroma 59022bs', spectrum=Spectrum(subtype='BS'), path='BS', reflects=False),
+                FilterPlacement(name='Semrock FF02-641/75', spectrum=Spectrum(subtype='BP'), path='EM', reflects=False)
+            ],
+            camera=SpectrumOwner(name='Andor Zyla 4.2 PLUS', spectrum=Spectrum(subtype='QE')),
+            light=SpectrumOwner(name='SOLA 395', spectrum=Spectrum(subtype='PD')),
+            laser=None
+        ),
+        OpticalConfig(
+            name='Widefield Far-Red',
+            filters=[
+                FilterPlacement(name='Chroma ET640/30x', spectrum=Spectrum(subtype='BX'), path='EX', reflects=False),
+                FilterPlacement(name='Chroma T660lpxr', spectrum=Spectrum(subtype='LP'), path='BS', reflects=False),
+                FilterPlacement(name='Semrock FF01-698/70', spectrum=Spectrum(subtype='BP'), path='EM', reflects=False)
+            ],
+            camera=SpectrumOwner(name='Andor Zyla 4.2 PLUS', spectrum=Spectrum(subtype='QE')),
+            light=SpectrumOwner(name='SOLA 395', spectrum=Spectrum(subtype='PD')),
+            laser=None
+        ),
+        OpticalConfig(
+            name='Widefield Triple Cyan',
+            filters=[
+                FilterPlacement(name='Lumencor 440/20x', spectrum=Spectrum(subtype='BX'), path='EX', reflects=False),
+                FilterPlacement(name='Chroma 69008bs', spectrum=Spectrum(subtype='BS'), path='BS', reflects=False),
+                FilterPlacement(name='Chroma ET470/24m', spectrum=Spectrum(subtype='BM'), path='EM', reflects=False)
+            ],
+            camera=SpectrumOwner(name='Andor Zyla 4.2 PLUS', spectrum=Spectrum(subtype='QE')),
+            light=SpectrumOwner(name='SOLA 395', spectrum=Spectrum(subtype='PD')),
+            laser=None
+        ),
+        OpticalConfig(
+            name='Widefield Triple FRET',
+            filters=[
+                FilterPlacement(name='Lumencor 440/20x', spectrum=Spectrum(subtype='BX'), path='EX', reflects=False),
+                FilterPlacement(name='Chroma 69008bs', spectrum=Spectrum(subtype='BS'), path='BS', reflects=False),
+                FilterPlacement(name='Chroma ET535/30m', spectrum=Spectrum(subtype='BM'), path='EM', reflects=False)
+            ],
+            camera=SpectrumOwner(name='Andor Zyla 4.2 PLUS', spectrum=Spectrum(subtype='QE')),
+            light=SpectrumOwner(name='SOLA 395', spectrum=Spectrum(subtype='PD')),
+            laser=None
+        ),
+        OpticalConfig(
+            name='Widefield Triple Red',
+            filters=[
+                FilterPlacement(name='Lumencor 575/25x', spectrum=Spectrum(subtype='BX'), path='EX', reflects=False),
+                FilterPlacement(name='Chroma 69008bs', spectrum=Spectrum(subtype='BS'), path='BS', reflects=False),
+                FilterPlacement(name='Semrock FF02-641/75', spectrum=Spectrum(subtype='BP'), path='EM', reflects=False)
+            ],
+            camera=SpectrumOwner(name='Andor Zyla 4.2 PLUS', spectrum=Spectrum(subtype='QE')),
+            light=SpectrumOwner(name='SOLA 395', spectrum=Spectrum(subtype='PD')),
+            laser=None
+        ),
+        OpticalConfig(
+            name='Widefield Triple Yellow',
+            filters=[
+                FilterPlacement(name='Chroma ET500/20x', spectrum=Spectrum(subtype='BX'), path='EX', reflects=False),
+                FilterPlacement(name='Chroma 69008bs', spectrum=Spectrum(subtype='BS'), path='BS', reflects=False),
+                FilterPlacement(name='Chroma ET535/30m', spectrum=Spectrum(subtype='BM'), path='EM', reflects=False)
+            ],
+            camera=SpectrumOwner(name='Andor Zyla 4.2 PLUS', spectrum=Spectrum(subtype='QE')),
+            light=SpectrumOwner(name='SOLA 395', spectrum=Spectrum(subtype='PD')),
+            laser=None
+        )
+    ]
+)
+```

fpbase-0.0.1.dist-info/RECORD

@@ -0,0 +1,9 @@
+fpbase/__init__.py,sha256=Y0HgKVLDTclYpfYyEt-tD3B58ab2fi8wN3KST0JijTE,485
+fpbase/_fetch.py,sha256=KF307XNFXSWPmJQoLk0nmw4dCWehK0udnCk-j9b7AoI,5782
+fpbase/_graphql.py,sha256=x1NZ4fmVvY1ghi0TE6w_qjMIwvy0DOnwJRRNHGMUTtY,1268
+fpbase/models.py,sha256=gNyTdfSJ-Kv2N8savlNtgo3o2Y84LOOnxLRLsTF9pLY,5559
+fpbase/py.typed,sha256=esB4cHc6c07uVkGtqf8at7ttEnprwRxwk8obY8Qumq4,187
+fpbase-0.0.1.dist-info/METADATA,sha256=KdFuK6UEuac3fW1zDApiyl4Hc4rAyOMY9dFlekVs9JU,9176
+fpbase-0.0.1.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
+fpbase-0.0.1.dist-info/licenses/LICENSE,sha256=pY8jqpmjisIM7lVsbSEw4b-PUVnM8_ZSFlmLVdrXmxk,1501
+fpbase-0.0.1.dist-info/RECORD,,

fpbase-0.0.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.26.3
+Root-Is-Purelib: true
+Tag: py3-none-any

fpbase-0.0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2023, Talley Lambert
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.