1839 lines
75 KiB
Python
1839 lines
75 KiB
Python
"""
|
|
All kit and reagent related models
|
|
"""
|
|
from __future__ import annotations
|
|
|
|
import datetime
|
|
import json
|
|
from pprint import pprint, pformat
|
|
|
|
from sqlalchemy import Column, String, TIMESTAMP, JSON, INTEGER, ForeignKey, Interval, Table, FLOAT, BLOB
|
|
from sqlalchemy.orm import relationship, validates, Query
|
|
from sqlalchemy.ext.associationproxy import association_proxy
|
|
from datetime import date
|
|
import logging, re
|
|
from tools import check_authorization, setup_lookup, Report, Result
|
|
from typing import List, Literal, Generator, Any
|
|
from pandas import ExcelFile
|
|
from pathlib import Path
|
|
from . import Base, BaseClass, Organization
|
|
from io import BytesIO
|
|
|
|
logger = logging.getLogger(f'submissions.{__name__}')
|
|
|
|
# logger.debug("Table for ReagentType/Reagent relations")
|
|
reagentroles_reagents = Table(
|
|
"_reagentroles_reagents",
|
|
Base.metadata,
|
|
Column("reagent_id", INTEGER, ForeignKey("_reagent.id")),
|
|
Column("reagentrole_id", INTEGER, ForeignKey("_reagentrole.id")),
|
|
extend_existing=True
|
|
)
|
|
|
|
# logger.debug("Table for EquipmentRole/Equipment relations")
|
|
equipmentroles_equipment = Table(
|
|
"_equipmentroles_equipment",
|
|
Base.metadata,
|
|
Column("equipment_id", INTEGER, ForeignKey("_equipment.id")),
|
|
Column("equipmentroles_id", INTEGER, ForeignKey("_equipmentrole.id")),
|
|
extend_existing=True
|
|
)
|
|
|
|
# logger.debug("Table for Equipment/Process relations")
|
|
equipment_processes = Table(
|
|
"_equipment_processes",
|
|
Base.metadata,
|
|
Column("process_id", INTEGER, ForeignKey("_process.id")),
|
|
Column("equipment_id", INTEGER, ForeignKey("_equipment.id")),
|
|
extend_existing=True
|
|
)
|
|
|
|
# logger.debug("Table for EquipmentRole/Process relations")
|
|
equipmentroles_processes = Table(
|
|
"_equipmentroles_processes",
|
|
Base.metadata,
|
|
Column("process_id", INTEGER, ForeignKey("_process.id")),
|
|
Column("equipmentrole_id", INTEGER, ForeignKey("_equipmentrole.id")),
|
|
extend_existing=True
|
|
)
|
|
|
|
# logger.debug("Table for SubmissionType/Process relations")
|
|
submissiontypes_processes = Table(
|
|
"_submissiontypes_processes",
|
|
Base.metadata,
|
|
Column("process_id", INTEGER, ForeignKey("_process.id")),
|
|
Column("equipmentroles_id", INTEGER, ForeignKey("_submissiontype.id")),
|
|
extend_existing=True
|
|
)
|
|
|
|
# logger.debug("Table for KitType/Process relations")
|
|
kittypes_processes = Table(
|
|
"_kittypes_processes",
|
|
Base.metadata,
|
|
Column("process_id", INTEGER, ForeignKey("_process.id")),
|
|
Column("kit_id", INTEGER, ForeignKey("_kittype.id")),
|
|
extend_existing=True
|
|
)
|
|
|
|
# logger.debug("Table for TipRole/Tips relations")
|
|
tiproles_tips = Table(
|
|
"_tiproles_tips",
|
|
Base.metadata,
|
|
Column("tiprole_id", INTEGER, ForeignKey("_tiprole.id")),
|
|
Column("tips_id", INTEGER, ForeignKey("_tips.id")),
|
|
extend_existing=True
|
|
)
|
|
|
|
# logger.debug("Table for Process/TipRole relations")
|
|
process_tiprole = Table(
|
|
"_process_tiprole",
|
|
Base.metadata,
|
|
Column("process_id", INTEGER, ForeignKey("_process.id")),
|
|
Column("tiprole_id", INTEGER, ForeignKey("_tiprole.id")),
|
|
extend_existing=True
|
|
)
|
|
|
|
# logger.debug("Table for Equipment/Tips relations")
|
|
equipment_tips = Table(
|
|
"_equipment_tips",
|
|
Base.metadata,
|
|
Column("equipment_id", INTEGER, ForeignKey("_equipment.id")),
|
|
Column("tips_id", INTEGER, ForeignKey("_tips.id")),
|
|
extend_existing=True
|
|
)
|
|
|
|
|
|
class KitType(BaseClass):
|
|
"""
|
|
Base of kits used in submission processing
|
|
"""
|
|
|
|
id = Column(INTEGER, primary_key=True) #: primary key
|
|
name = Column(String(64), unique=True) #: name of kit
|
|
submissions = relationship("BasicSubmission", back_populates="extraction_kit") #: submissions this kit was used for
|
|
processes = relationship("Process", back_populates="kit_types",
|
|
secondary=kittypes_processes) #: equipment processes used by this kit
|
|
|
|
kit_reagentrole_associations = relationship(
|
|
"KitTypeReagentRoleAssociation",
|
|
back_populates="kit_type",
|
|
cascade="all, delete-orphan",
|
|
)
|
|
|
|
# creator function: https://stackoverflow.com/questions/11091491/keyerror-when-adding-objects-to-sqlalchemy-association-object/11116291#11116291
|
|
reagent_roles = association_proxy("kit_reagentrole_associations", "reagent_role",
|
|
creator=lambda RT: KitTypeReagentRoleAssociation(
|
|
reagent_role=RT)) #: Association proxy to KitTypeReagentRoleAssociation
|
|
|
|
kit_submissiontype_associations = relationship(
|
|
"SubmissionTypeKitTypeAssociation",
|
|
back_populates="kit_type",
|
|
cascade="all, delete-orphan",
|
|
) #: Relation to SubmissionType
|
|
|
|
used_for = association_proxy("kit_submissiontype_associations", "submission_type",
|
|
creator=lambda ST: SubmissionTypeKitTypeAssociation(
|
|
submission_type=ST)) #: Association proxy to SubmissionTypeKitTypeAssociation
|
|
|
|
def __repr__(self) -> str:
|
|
"""
|
|
Returns:
|
|
str: A representation of the object.
|
|
"""
|
|
return f"<KitType({self.name})>"
|
|
|
|
def get_reagents(self, required: bool = False, submission_type: str | SubmissionType | None = None) -> List[
|
|
ReagentRole]:
|
|
"""
|
|
Return ReagentTypes linked to kit through KitTypeReagentTypeAssociation.
|
|
|
|
Args:
|
|
required (bool, optional): If true only return required types. Defaults to False.
|
|
submission_type (str | Submissiontype | None, optional): Submission type to narrow results. Defaults to None.
|
|
|
|
Returns:
|
|
List[ReagentRole]: List of reagents linked to this kit.
|
|
"""
|
|
match submission_type:
|
|
case SubmissionType():
|
|
# logger.debug(f"Getting reagents by SubmissionType {submission_type}")
|
|
relevant_associations = [item for item in self.kit_reagentrole_associations if
|
|
item.submission_type == submission_type]
|
|
case str():
|
|
# logger.debug(f"Getting reagents by str {submission_type}")
|
|
relevant_associations = [item for item in self.kit_reagentrole_associations if
|
|
item.submission_type.name == submission_type]
|
|
case _:
|
|
# logger.debug(f"Getting reagents")
|
|
relevant_associations = [item for item in self.kit_reagentrole_associations]
|
|
if required:
|
|
# logger.debug(f"Filtering by required.")
|
|
return [item.reagent_role for item in relevant_associations if item.required == 1]
|
|
else:
|
|
return [item.reagent_role for item in relevant_associations]
|
|
|
|
# TODO: Move to BasicSubmission?
|
|
def construct_xl_map_for_use(self, submission_type: str | SubmissionType) -> Generator[str, str]:
|
|
"""
|
|
Creates map of locations in Excel workbook for a SubmissionType
|
|
|
|
Args:
|
|
submission_type (str | SubmissionType): Submissiontype.name
|
|
|
|
Returns:
|
|
dict: Dictionary containing information locations.
|
|
"""
|
|
# info_map = {}
|
|
# NOTE: Account for submission_type variable type.
|
|
match submission_type:
|
|
case str():
|
|
# logger.debug(f"Constructing xl map with str {submission_type}")
|
|
assocs = [item for item in self.kit_reagentrole_associations if
|
|
item.submission_type.name == submission_type]
|
|
case SubmissionType():
|
|
# logger.debug(f"Constructing xl map with SubmissionType {submission_type}")
|
|
assocs = [item for item in self.kit_reagentrole_associations if item.submission_type == submission_type]
|
|
case _:
|
|
raise ValueError(f"Wrong variable type: {type(submission_type)} used!")
|
|
# logger.debug("Get all KitTypeReagentTypeAssociation for SubmissionType")
|
|
for assoc in assocs:
|
|
try:
|
|
yield assoc.reagent_role.name, assoc.uses
|
|
except TypeError:
|
|
continue
|
|
# return info_map
|
|
|
|
@classmethod
|
|
@setup_lookup
|
|
def query(cls,
|
|
name: str = None,
|
|
used_for: str | SubmissionType | None = None,
|
|
id: int | None = None,
|
|
limit: int = 0
|
|
) -> KitType | List[KitType]:
|
|
"""
|
|
Lookup a list of or single KitType.
|
|
|
|
Args:
|
|
name (str, optional): Name of desired kit (returns single instance). Defaults to None.
|
|
used_for (str | Submissiontype | None, optional): Submission type the kit is used for. Defaults to None.
|
|
id (int | None, optional): Kit id in the database. Defaults to None.
|
|
limit (int, optional): Maximum number of results to return (0 = all). Defaults to 0.
|
|
|
|
Returns:
|
|
models.KitType|List[models.KitType]: KitType(s) of interest.
|
|
"""
|
|
query: Query = cls.__database_session__.query(cls)
|
|
match used_for:
|
|
case str():
|
|
# logger.debug(f"Looking up kit type by used_for str: {used_for}")
|
|
query = query.filter(cls.used_for.any(name=used_for))
|
|
case SubmissionType():
|
|
# logger.debug(f"Looking up kit type by used_for SubmissionType: {used_for}")
|
|
query = query.filter(cls.used_for.contains(used_for))
|
|
case _:
|
|
pass
|
|
match name:
|
|
case str():
|
|
# logger.debug(f"Looking up kit type by name str: {name}")
|
|
query = query.filter(cls.name == name)
|
|
limit = 1
|
|
case _:
|
|
pass
|
|
match id:
|
|
case int():
|
|
# logger.debug(f"Looking up kit type by id int: {id}")
|
|
query = query.filter(cls.id == id)
|
|
limit = 1
|
|
case str():
|
|
# logger.debug(f"Looking up kit type by id str: {id}")
|
|
query = query.filter(cls.id == int(id))
|
|
limit = 1
|
|
case _:
|
|
pass
|
|
return cls.execute_query(query=query, limit=limit)
|
|
|
|
@check_authorization
|
|
def save(self):
|
|
super().save()
|
|
|
|
def to_export_dict(self, submission_type: SubmissionType):
|
|
base_dict = dict(name=self.name)
|
|
base_dict['reagent roles'] = []
|
|
base_dict['equipment roles'] = []
|
|
for k, v in self.construct_xl_map_for_use(submission_type=submission_type):
|
|
# logger.debug(f"Value: {v}")
|
|
try:
|
|
assoc = [item for item in self.kit_reagentrole_associations if item.reagent_role.name == k][0]
|
|
except IndexError as e:
|
|
continue
|
|
for kk, vv in assoc.to_export_dict().items():
|
|
v[kk] = vv
|
|
base_dict['reagent roles'].append(v)
|
|
for k, v in submission_type.construct_equipment_map():
|
|
try:
|
|
assoc = [item for item in submission_type.submissiontype_equipmentrole_associations if
|
|
item.equipment_role.name == k][0]
|
|
except IndexError:
|
|
continue
|
|
for kk, vv in assoc.to_export_dict(kit_type=self).items():
|
|
# logger.debug(f"{kk}:{vv}")
|
|
v[kk] = vv
|
|
base_dict['equipment roles'].append(v)
|
|
# logger.debug(f"KT returning {base_dict}")
|
|
return base_dict
|
|
|
|
|
|
class ReagentRole(BaseClass):
|
|
"""
|
|
Base of reagent type abstract
|
|
"""
|
|
|
|
id = Column(INTEGER, primary_key=True) #: primary key
|
|
name = Column(String(64)) #: name of reagent type
|
|
instances = relationship("Reagent", back_populates="role",
|
|
secondary=reagentroles_reagents) #: concrete instances of this reagent type
|
|
eol_ext = Column(Interval()) #: extension of life interval
|
|
|
|
reagentrole_kit_associations = relationship(
|
|
"KitTypeReagentRoleAssociation",
|
|
back_populates="reagent_role",
|
|
cascade="all, delete-orphan",
|
|
) #: Relation to KitTypeReagentTypeAssociation
|
|
|
|
# creator function: https://stackoverflow.com/questions/11091491/keyerror-when-adding-objects-to-sqlalchemy-association-object/11116291#11116291
|
|
kit_types = association_proxy("reagentrole_kit_associations", "kit_type",
|
|
creator=lambda kit: KitTypeReagentRoleAssociation(
|
|
kit_type=kit)) #: Association proxy to KitTypeReagentRoleAssociation
|
|
|
|
def __repr__(self) -> str:
|
|
"""
|
|
Returns:
|
|
str: Representation of object
|
|
"""
|
|
return f"<ReagentRole({self.name})>"
|
|
|
|
@classmethod
|
|
@setup_lookup
|
|
def query(cls,
|
|
name: str | None = None,
|
|
kit_type: KitType | str | None = None,
|
|
reagent: Reagent | str | None = None,
|
|
limit: int = 0,
|
|
) -> ReagentRole | List[ReagentRole]:
|
|
"""
|
|
Lookup reagent types in the database.
|
|
|
|
Args:
|
|
name (str | None, optional): Reagent type name. Defaults to None.
|
|
kit_type (KitType | str | None, optional): Kit the type of interest belongs to. Defaults to None.
|
|
reagent (Reagent | str | None, optional): Concrete instance of the type of interest. Defaults to None.
|
|
limit (int, optional): maxmimum number of results to return (0 = all). Defaults to 0.
|
|
|
|
Raises:
|
|
ValueError: Raised if only kit_type or reagent, not both, given.
|
|
|
|
Returns:
|
|
ReagentRole|List[ReagentRole]: ReagentRole or list of ReagentRoles matching filter.
|
|
"""
|
|
query: Query = cls.__database_session__.query(cls)
|
|
if (kit_type is not None and reagent is None) or (reagent is not None and kit_type is None):
|
|
raise ValueError("Cannot filter without both reagent and kit type.")
|
|
elif kit_type is None and reagent is None:
|
|
pass
|
|
else:
|
|
match kit_type:
|
|
case str():
|
|
# logger.debug(f"Lookup ReagentType by kittype str {kit_type}")
|
|
kit_type = KitType.query(name=kit_type)
|
|
case _:
|
|
pass
|
|
match reagent:
|
|
case str():
|
|
# logger.debug(f"Lookup ReagentType by reagent str {reagent}")
|
|
reagent = Reagent.query(lot_number=reagent)
|
|
case _:
|
|
pass
|
|
assert reagent.role
|
|
# logger.debug(f"Looking up reagent type for {type(kit_type)} {kit_type} and {type(reagent)} {reagent}")
|
|
# logger.debug(f"Kit reagent types: {kit_type.reagent_types}")
|
|
result = list(set(kit_type.reagent_roles).intersection(reagent.role))
|
|
# logger.debug(f"Result: {result}")
|
|
try:
|
|
return result[0]
|
|
except IndexError:
|
|
return None
|
|
match name:
|
|
case str():
|
|
# logger.debug(f"Looking up reagent type by name str: {name}")
|
|
query = query.filter(cls.name == name)
|
|
limit = 1
|
|
case _:
|
|
pass
|
|
return cls.execute_query(query=query, limit=limit)
|
|
|
|
def to_pydantic(self) -> "PydReagent":
|
|
"""
|
|
Create default PydReagent from this object
|
|
|
|
Returns:
|
|
PydReagent: PydReagent representation of this object.
|
|
"""
|
|
from backend.validators.pydant import PydReagent
|
|
return PydReagent(lot=None, role=self.name, name=self.name, expiry=date.today())
|
|
|
|
def to_export_dict(self):
|
|
return dict(role=self.name, extension_of_life=self.eol_ext.days)
|
|
|
|
@check_authorization
|
|
def save(self):
|
|
super().save()
|
|
|
|
|
|
class Reagent(BaseClass):
|
|
"""
|
|
Concrete reagent instance
|
|
"""
|
|
|
|
id = Column(INTEGER, primary_key=True) #: primary key
|
|
role = relationship("ReagentRole", back_populates="instances",
|
|
secondary=reagentroles_reagents) #: joined parent reagent type
|
|
role_id = Column(INTEGER, ForeignKey("_reagentrole.id", ondelete='SET NULL',
|
|
name="fk_reagent_role_id")) #: id of parent reagent type
|
|
name = Column(String(64)) #: reagent name
|
|
lot = Column(String(64)) #: lot number of reagent
|
|
expiry = Column(TIMESTAMP) #: expiry date - extended by eol_ext of parent programmatically
|
|
|
|
reagent_submission_associations = relationship(
|
|
"SubmissionReagentAssociation",
|
|
back_populates="reagent",
|
|
cascade="all, delete-orphan",
|
|
) #: Relation to SubmissionSampleAssociation
|
|
|
|
submissions = association_proxy("reagent_submission_associations", "submission",
|
|
creator=lambda sub: SubmissionReagentAssociation(
|
|
submission=sub)) #: Association proxy to SubmissionSampleAssociation.samples
|
|
|
|
def __repr__(self):
|
|
if self.name is not None:
|
|
return f"<Reagent({self.name}-{self.lot})>"
|
|
else:
|
|
return f"<Reagent({self.role.name}-{self.lot})>"
|
|
|
|
def to_sub_dict(self, extraction_kit: KitType = None) -> dict:
|
|
"""
|
|
dictionary containing values necessary for gui
|
|
|
|
Args:
|
|
extraction_kit (KitType, optional): KitType to use to get reagent type. Defaults to None.
|
|
|
|
Returns:
|
|
dict: representation of the reagent's attributes
|
|
"""
|
|
if extraction_kit is not None:
|
|
# NOTE: Get the intersection of this reagent's ReagentType and all ReagentTypes in KitType
|
|
try:
|
|
reagent_role = list(set(self.role).intersection(extraction_kit.reagent_roles))[0]
|
|
# NOTE: Most will be able to fall back to first ReagentType in itself because most will only have 1.
|
|
except:
|
|
reagent_role = self.role[0]
|
|
else:
|
|
reagent_role = self.role[0]
|
|
try:
|
|
rtype = reagent_role.name.replace("_", " ")
|
|
except AttributeError:
|
|
rtype = "Unknown"
|
|
# logger.debug(f"Role for {self.name}: {rtype}")
|
|
# NOTE: Calculate expiry with EOL from ReagentType
|
|
try:
|
|
place_holder = self.expiry + reagent_role.eol_ext
|
|
except (TypeError, AttributeError) as e:
|
|
place_holder = date.today()
|
|
logger.error(f"We got a type error setting {self.lot} expiry: {e}. setting to today for testing")
|
|
# NOTE: The notation for not having an expiry is 1970.1.1
|
|
if self.expiry.year == 1970:
|
|
place_holder = "NA"
|
|
else:
|
|
place_holder = place_holder.strftime("%Y-%m-%d")
|
|
return dict(
|
|
name=self.name,
|
|
role=rtype,
|
|
lot=self.lot,
|
|
expiry=place_holder,
|
|
missing=False
|
|
)
|
|
|
|
def update_last_used(self, kit: KitType) -> Report:
|
|
"""
|
|
Updates last used reagent lot for ReagentType/KitType
|
|
|
|
Args:
|
|
kit (KitType): Kit this instance is used in.
|
|
|
|
Returns:
|
|
Report: Result of operation
|
|
"""
|
|
report = Report()
|
|
# logger.debug(f"Attempting update of last used reagent type at intersection of ({self}), ({kit})")
|
|
rt = ReagentRole.query(kit_type=kit, reagent=self, limit=1)
|
|
if rt is not None:
|
|
# logger.debug(f"got reagenttype {rt}")
|
|
assoc = KitTypeReagentRoleAssociation.query(kit_type=kit, reagent_role=rt)
|
|
if assoc is not None:
|
|
if assoc.last_used != self.lot:
|
|
# logger.debug(f"Updating {assoc} last used to {self.lot}")
|
|
assoc.last_used = self.lot
|
|
result = assoc.save()
|
|
report.add_result(result)
|
|
return report
|
|
report.add_result(Result(msg=f"Updating last used {rt} was not performed.", status="Information"))
|
|
return report
|
|
|
|
@classmethod
|
|
@setup_lookup
|
|
def query(cls,
|
|
id: int | None = None,
|
|
reagent_role: str | ReagentRole | None = None,
|
|
lot_number: str | None = None,
|
|
name: str | None = None,
|
|
limit: int = 0
|
|
) -> Reagent | List[Reagent]:
|
|
"""
|
|
Lookup a list of reagents from the database.
|
|
|
|
Args:
|
|
id (int | None, optional): reagent id number
|
|
reagent_role (str | models.ReagentType | None, optional): Reagent type. Defaults to None.
|
|
lot_number (str | None, optional): Reagent lot number. Defaults to None.
|
|
name (str | None, optional): Reagent name. Defaults to None.
|
|
limit (int, optional): limit of results returned. Defaults to 0.
|
|
|
|
Returns:
|
|
models.Reagent | List[models.Reagent]: reagent or list of reagents matching filter.
|
|
"""
|
|
query: Query = cls.__database_session__.query(cls)
|
|
match id:
|
|
case int():
|
|
query = query.filter(cls.id == id)
|
|
limit = 1
|
|
case _:
|
|
pass
|
|
match reagent_role:
|
|
case str():
|
|
# logger.debug(f"Looking up reagents by reagent type str: {reagent_type}")
|
|
query = query.join(cls.role).filter(ReagentRole.name == reagent_role)
|
|
case ReagentRole():
|
|
# logger.debug(f"Looking up reagents by reagent type ReagentType: {reagent_type}")
|
|
query = query.filter(cls.role.contains(reagent_role))
|
|
case _:
|
|
pass
|
|
match name:
|
|
case str():
|
|
# logger.debug(f"Looking up reagent by name str: {name}")
|
|
# NOTE: Not limited due to multiple reagents having same name.
|
|
query = query.filter(cls.name == name)
|
|
case _:
|
|
pass
|
|
match lot_number:
|
|
case str():
|
|
# logger.debug(f"Looking up reagent by lot number str: {lot_number}")
|
|
query = query.filter(cls.lot == lot_number)
|
|
# NOTE: In this case limit number returned.
|
|
limit = 1
|
|
case _:
|
|
pass
|
|
return cls.execute_query(query=query, limit=limit)
|
|
|
|
|
|
class Discount(BaseClass):
|
|
"""
|
|
Relationship table for client labs for certain kits.
|
|
"""
|
|
|
|
id = Column(INTEGER, primary_key=True) #: primary key
|
|
kit = relationship("KitType") #: joined parent reagent type
|
|
kit_id = Column(INTEGER, ForeignKey("_kittype.id", ondelete='SET NULL', name="fk_kit_type_id")) #: id of joined kit
|
|
client = relationship("Organization") #: joined client lab
|
|
client_id = Column(INTEGER,
|
|
ForeignKey("_organization.id", ondelete='SET NULL', name="fk_org_id")) #: id of joined client
|
|
name = Column(String(128)) #: Short description
|
|
amount = Column(FLOAT(2)) #: Dollar amount of discount
|
|
|
|
def __repr__(self) -> str:
|
|
"""
|
|
Returns:
|
|
str: Representation of this object
|
|
"""
|
|
return f"<Discount({self.name})>"
|
|
|
|
@classmethod
|
|
@setup_lookup
|
|
def query(cls,
|
|
organization: Organization | str | int | None = None,
|
|
kit_type: KitType | str | int | None = None,
|
|
) -> Discount | List[Discount]:
|
|
"""
|
|
Lookup discount objects (union of kit and organization)
|
|
|
|
Args:
|
|
organization (models.Organization | str | int): Organization receiving discount.
|
|
kit_type (models.KitType | str | int): Kit discount received on.
|
|
|
|
Returns:
|
|
models.Discount|List[models.Discount]: Discount(s) of interest.
|
|
"""
|
|
query: Query = cls.__database_session__.query(cls)
|
|
match organization:
|
|
case Organization():
|
|
# logger.debug(f"Looking up discount with organization Organization: {organization}")
|
|
query = query.filter(cls.client == Organization)
|
|
case str():
|
|
# logger.debug(f"Looking up discount with organization str: {organization}")
|
|
query = query.join(Organization).filter(Organization.name == organization)
|
|
case int():
|
|
# logger.debug(f"Looking up discount with organization id: {organization}")
|
|
query = query.join(Organization).filter(Organization.id == organization)
|
|
case _:
|
|
pass
|
|
match kit_type:
|
|
case KitType():
|
|
# logger.debug(f"Looking up discount with kit type KitType: {kit_type}")
|
|
query = query.filter(cls.kit == kit_type)
|
|
case str():
|
|
# logger.debug(f"Looking up discount with kit type str: {kit_type}")
|
|
query = query.join(KitType).filter(KitType.name == kit_type)
|
|
case int():
|
|
# logger.debug(f"Looking up discount with kit type id: {kit_type}")
|
|
query = query.join(KitType).filter(KitType.id == kit_type)
|
|
case _:
|
|
pass
|
|
return cls.execute_query(query=query)
|
|
|
|
@check_authorization
|
|
def save(self):
|
|
super().save()
|
|
|
|
|
|
class SubmissionType(BaseClass):
|
|
"""
|
|
Abstract of types of submissions.
|
|
"""
|
|
|
|
id = Column(INTEGER, primary_key=True) #: primary key
|
|
name = Column(String(128), unique=True) #: name of submission type
|
|
info_map = Column(JSON) #: Where basic information is found in the excel workbook corresponding to this type.
|
|
defaults = Column(JSON) #: Basic information about this submission type
|
|
instances = relationship("BasicSubmission", backref="submission_type") #: Concrete instances of this type.
|
|
template_file = Column(BLOB) #: Blank form for this type stored as binary.
|
|
processes = relationship("Process", back_populates="submission_types",
|
|
secondary=submissiontypes_processes) #: Relation to equipment processes used for this type.
|
|
sample_map = Column(JSON) #: Where sample information is found in the excel sheet corresponding to this type.
|
|
|
|
submissiontype_kit_associations = relationship(
|
|
"SubmissionTypeKitTypeAssociation",
|
|
back_populates="submission_type",
|
|
cascade="all, delete-orphan",
|
|
) #: Association of kittypes
|
|
|
|
kit_types = association_proxy("submissiontype_kit_associations", "kit_type",
|
|
creator=lambda kit: SubmissionTypeKitTypeAssociation(
|
|
kit_type=kit)) #: Proxy of kittype association
|
|
|
|
submissiontype_equipmentrole_associations = relationship(
|
|
"SubmissionTypeEquipmentRoleAssociation",
|
|
back_populates="submission_type",
|
|
cascade="all, delete-orphan"
|
|
) #: Association of equipmentroles
|
|
|
|
equipment = association_proxy("submissiontype_equipmentrole_associations", "equipment_role",
|
|
creator=lambda eq: SubmissionTypeEquipmentRoleAssociation(
|
|
equipment_role=eq)) #: Proxy of equipmentrole associations
|
|
|
|
submissiontype_kit_rt_associations = relationship(
|
|
"KitTypeReagentRoleAssociation",
|
|
back_populates="submission_type",
|
|
cascade="all, delete-orphan"
|
|
) #: triple association of KitTypes, ReagentTypes, SubmissionTypes
|
|
|
|
submissiontype_tiprole_associations = relationship(
|
|
"SubmissionTypeTipRoleAssociation",
|
|
back_populates="submission_type",
|
|
cascade="all, delete-orphan"
|
|
)
|
|
|
|
def __repr__(self) -> str:
|
|
"""
|
|
Returns:
|
|
str: Representation of this object.
|
|
"""
|
|
return f"<SubmissionType({self.name})>"
|
|
|
|
def get_template_file_sheets(self) -> List[str]:
|
|
"""
|
|
Gets names of sheet in the stored blank form.
|
|
|
|
Returns:
|
|
List[str]: List of sheet names
|
|
"""
|
|
return ExcelFile(BytesIO(self.template_file), engine="openpyxl").sheet_names
|
|
|
|
def set_template_file(self, filepath: Path | str):
|
|
"""
|
|
|
|
Sets the binary store to an excel file.
|
|
|
|
Args:
|
|
filepath (Path | str): Path to the template file.
|
|
|
|
Raises:
|
|
ValueError: Raised if file is not excel file.
|
|
"""
|
|
if isinstance(filepath, str):
|
|
filepath = Path(filepath)
|
|
try:
|
|
ExcelFile(filepath)
|
|
except ValueError:
|
|
raise ValueError(f"File {filepath} is not of appropriate type.")
|
|
with open(filepath, "rb") as f:
|
|
data = f.read()
|
|
self.template_file = data
|
|
self.save()
|
|
|
|
def construct_info_map(self, mode: Literal['read', 'write', 'export']) -> dict:
|
|
"""
|
|
Make of map of where all fields are located in Excel sheet
|
|
|
|
Args:
|
|
mode (Literal["read", "write"]): Which mode to get locations for
|
|
|
|
Returns:
|
|
dict: Map of locations
|
|
"""
|
|
info = {k: v for k, v in self.info_map.items() if k != "custom"}
|
|
logger.debug(f"Info map: {info}")
|
|
match mode:
|
|
case "read":
|
|
output = {k: v[mode] for k, v in info.items() if v[mode]}
|
|
case "write":
|
|
output = {k: v[mode] + v['read'] for k, v in info.items() if v[mode] or v['read']}
|
|
output = {k: v for k, v in output.items() if all([isinstance(item, dict) for item in v])}
|
|
case "export":
|
|
return self.info_map
|
|
case _:
|
|
output = {}
|
|
output['custom'] = self.info_map['custom']
|
|
return output
|
|
|
|
def construct_sample_map(self) -> dict:
|
|
"""
|
|
Returns sample map
|
|
|
|
Returns:
|
|
dict: sample location map
|
|
"""
|
|
return self.sample_map
|
|
|
|
def construct_equipment_map(self) -> Generator[str, dict]:
|
|
"""
|
|
Constructs map of equipment to excel cells.
|
|
|
|
Returns:
|
|
dict: Map equipment locations in excel sheet
|
|
"""
|
|
# output = {}
|
|
# logger.debug("Iterating through equipment roles")
|
|
for item in self.submissiontype_equipmentrole_associations:
|
|
emap = item.uses
|
|
if emap is None:
|
|
emap = {}
|
|
# output[item.equipment_role.name] = emap
|
|
yield item.equipment_role.name, emap
|
|
# return output
|
|
|
|
def construct_tips_map(self) -> Generator[str, dict]:
|
|
"""
|
|
Constructs map of tips to excel cells.
|
|
|
|
Returns:
|
|
dict: Tip locations in the excel sheet.
|
|
"""
|
|
# output = {}
|
|
for item in self.submissiontype_tiprole_associations:
|
|
tmap = item.uses
|
|
if tmap is None:
|
|
tmap = {}
|
|
# output[item.tip_role.name] = tmap
|
|
yield item.tip_role.name, tmap
|
|
# return output
|
|
|
|
def get_equipment(self, extraction_kit: str | KitType | None = None) -> List['PydEquipmentRole']:
|
|
"""
|
|
Returns PydEquipmentRole of all equipment associated with this SubmissionType
|
|
|
|
Returns:
|
|
List[PydEquipmentRole]: List of equipment roles
|
|
"""
|
|
return [item.to_pydantic(submission_type=self, extraction_kit=extraction_kit) for item in self.equipment]
|
|
|
|
def get_processes_for_role(self, equipment_role: str | EquipmentRole, kit: str | KitType | None = None) -> list:
|
|
"""
|
|
Get processes associated with this SubmissionType for an EquipmentRole
|
|
|
|
Args:
|
|
equipment_role (str | EquipmentRole): EquipmentRole of interest
|
|
kit (str | KitType | None, optional): Kit of interest. Defaults to None.
|
|
|
|
Raises:
|
|
TypeError: Raised if wrong type given for equipmentrole
|
|
|
|
Returns:
|
|
list: list of associated processes
|
|
"""
|
|
match equipment_role:
|
|
case str():
|
|
# logger.debug(f"Getting processes for equipmentrole str {equipment_role}")
|
|
relevant = [item.get_all_processes(kit) for item in self.submissiontype_equipmentrole_associations if
|
|
item.equipment_role.name == equipment_role]
|
|
case EquipmentRole():
|
|
# logger.debug(f"Getting processes for equipmentrole EquipmentRole {equipment_role}")
|
|
relevant = [item.get_all_processes(kit) for item in self.submissiontype_equipmentrole_associations if
|
|
item.equipment_role == equipment_role]
|
|
case _:
|
|
raise TypeError(f"Type {type(equipment_role)} is not allowed")
|
|
return list(set([item for items in relevant for item in items if item is not None]))
|
|
|
|
def get_submission_class(self) -> "BasicSubmission":
|
|
"""
|
|
Gets submission class associated with this submission type.
|
|
|
|
Returns:
|
|
BasicSubmission: Submission class
|
|
"""
|
|
from .submissions import BasicSubmission
|
|
return BasicSubmission.find_polymorphic_subclass(polymorphic_identity=self.name)
|
|
|
|
@classmethod
|
|
@setup_lookup
|
|
def query(cls,
|
|
name: str | None = None,
|
|
key: str | None = None,
|
|
limit: int = 0
|
|
) -> SubmissionType | List[SubmissionType]:
|
|
"""
|
|
Lookup submission type in the database by a number of parameters
|
|
|
|
Args:
|
|
name (str | None, optional): Name of submission type. Defaults to None.
|
|
key (str | None, optional): A key present in the info-map to lookup. Defaults to None.
|
|
limit (int, optional): Maximum number of results to return (0 = all). Defaults to 0.
|
|
|
|
Returns:
|
|
models.SubmissionType|List[models.SubmissionType]: SubmissionType(s) of interest.
|
|
"""
|
|
query: Query = cls.__database_session__.query(cls)
|
|
match name:
|
|
case str():
|
|
# logger.debug(f"Looking up submission type by name str: {name}")
|
|
query = query.filter(cls.name == name)
|
|
limit = 1
|
|
case _:
|
|
pass
|
|
match key:
|
|
case str():
|
|
# logger.debug(f"Looking up submission type by info-map key str: {key}")
|
|
query = query.filter(cls.info_map.op('->')(key) is not None)
|
|
case _:
|
|
pass
|
|
return cls.execute_query(query=query, limit=limit)
|
|
|
|
def to_export_dict(self):
|
|
base_dict = dict(name=self.name)
|
|
base_dict['info'] = self.construct_info_map(mode='export')
|
|
base_dict['defaults'] = self.defaults
|
|
# base_dict['excel location maps']['kits'] = [{k: v for k, v in item.kit_type.construct_xl_map_for_use(submission_type=self)} for item in
|
|
# self.submissiontype_kit_associations]
|
|
base_dict['samples'] = self.construct_sample_map()
|
|
# base_dict['excel location maps']['equipment_roles'] = {k: v for k, v in self.construct_equipment_map()}
|
|
base_dict['kits'] = [item.to_export_dict() for item in self.submissiontype_kit_associations]
|
|
return base_dict
|
|
|
|
@check_authorization
|
|
def save(self):
|
|
"""
|
|
Adds this instances to the database and commits.
|
|
"""
|
|
super().save()
|
|
|
|
@classmethod
|
|
@check_authorization
|
|
def import_from_json(cls, filepath:Path|str):
|
|
if isinstance(filepath, str):
|
|
filepath = Path(filepath)
|
|
if not filepath.exists():
|
|
logging.critical(f"Given file could not be found.")
|
|
return None
|
|
with open(filepath, "r") as f:
|
|
import_dict = json.load(fp=f)
|
|
logger.debug(pformat(import_dict))
|
|
submission_type = cls.query(name=import_dict['name'])
|
|
if submission_type:
|
|
return submission_type
|
|
submission_type = cls()
|
|
submission_type.name = import_dict['name']
|
|
submission_type.info_map = import_dict['info']
|
|
submission_type.sample_map = import_dict['samples']
|
|
submission_type.defaults = import_dict['defaults']
|
|
for kit in import_dict['kits']:
|
|
new_kit = KitType.query(name=kit['kit_type']['name'])
|
|
if not new_kit:
|
|
new_kit = KitType(name=kit['kit_type']['name'])
|
|
for role in kit['kit_type']['reagent roles']:
|
|
new_role = ReagentRole.query(name=role['role'])
|
|
eol = datetime.timedelta(role['extension_of_life'])
|
|
if not new_role:
|
|
new_role = ReagentRole(name=role['role'], eol_ext=eol)
|
|
uses = dict(expiry=role['expiry'], lot=role['lot'], name=role['name'], sheet=role['sheet'])
|
|
ktrr_assoc = KitTypeReagentRoleAssociation(kit_type=new_kit, reagent_role=new_role, uses=uses)
|
|
ktrr_assoc.submission_type = submission_type
|
|
ktrr_assoc.required = role['required']
|
|
ktst_assoc = SubmissionTypeKitTypeAssociation(
|
|
kit_type=new_kit,
|
|
submission_type=submission_type,
|
|
mutable_cost_sample=kit['mutable_cost_sample'],
|
|
mutable_cost_column=kit['mutable_cost_column'],
|
|
constant_cost=kit['constant_cost']
|
|
)
|
|
for role in kit['kit_type']['equipment roles']:
|
|
new_role = EquipmentRole.query(name=role['role'])
|
|
if not new_role:
|
|
new_role = EquipmentRole(name=role['role'])
|
|
ster_assoc = SubmissionTypeEquipmentRoleAssociation(submission_type=submission_type, equipment_role=new_role)
|
|
try:
|
|
uses = dict(name=role['name'], process=role['process'], sheet=role['sheet'], static=role['static'])
|
|
except KeyError:
|
|
uses = None
|
|
ster_assoc.uses = uses
|
|
for process in role['processes']:
|
|
new_process = Process.query(name=process)
|
|
if not new_process:
|
|
new_process = Process(name=process)
|
|
new_process.submission_types.append(submission_type)
|
|
new_process.kit_types.append(new_kit)
|
|
new_process.equipment_roles.append(new_role)
|
|
return submission_type
|
|
|
|
|
|
class SubmissionTypeKitTypeAssociation(BaseClass):
|
|
"""
|
|
Abstract of relationship between kits and their submission type.
|
|
"""
|
|
|
|
submission_types_id = Column(INTEGER, ForeignKey("_submissiontype.id"),
|
|
primary_key=True) #: id of joined submission type
|
|
kits_id = Column(INTEGER, ForeignKey("_kittype.id"), primary_key=True) #: id of joined kit
|
|
mutable_cost_column = Column(
|
|
FLOAT(2)) #: dollar amount per 96 well plate that can change with number of columns (reagents, tips, etc)
|
|
mutable_cost_sample = Column(
|
|
FLOAT(2)) #: dollar amount that can change with number of samples (reagents, tips, etc)
|
|
constant_cost = Column(FLOAT(2)) #: dollar amount per plate that will remain constant (plates, man hours, etc)
|
|
|
|
kit_type = relationship(KitType, back_populates="kit_submissiontype_associations") #: joined kittype
|
|
|
|
# reference to the "SubmissionType" object
|
|
submission_type = relationship(SubmissionType,
|
|
back_populates="submissiontype_kit_associations") #: joined submission type
|
|
|
|
def __init__(self, kit_type=None, submission_type=None,
|
|
mutable_cost_column: int = 0.00, mutable_cost_sample: int = 0.00, constant_cost: int = 0.00):
|
|
self.kit_type = kit_type
|
|
self.submission_type = submission_type
|
|
self.mutable_cost_column = mutable_cost_column
|
|
self.mutable_cost_sample = mutable_cost_sample
|
|
self.constant_cost = constant_cost
|
|
|
|
def __repr__(self) -> str:
|
|
"""
|
|
Returns:
|
|
str: Representation of this object
|
|
"""
|
|
return f"<SubmissionTypeKitTypeAssociation({self.submission_type.name}&{self.kit_type.name})>"
|
|
|
|
@classmethod
|
|
@setup_lookup
|
|
def query(cls,
|
|
submission_type: SubmissionType | str | int | None = None,
|
|
kit_type: KitType | str | int | None = None,
|
|
limit: int = 0
|
|
) -> SubmissionTypeKitTypeAssociation | List[SubmissionTypeKitTypeAssociation]:
|
|
"""
|
|
Lookup SubmissionTypeKitTypeAssociations of interest.
|
|
|
|
Args:
|
|
submission_type (SubmissionType | str | int | None, optional): Identifier of submission type. Defaults to None.
|
|
kit_type (KitType | str | int | None, optional): Identifier of kit type. Defaults to None.
|
|
limit (int, optional): Maximum number of results to return (0 = all). Defaults to 0.
|
|
|
|
Returns:
|
|
SubmissionTypeKitTypeAssociation|List[SubmissionTypeKitTypeAssociation]: SubmissionTypeKitTypeAssociation(s) of interest
|
|
"""
|
|
query: Query = cls.__database_session__.query(cls)
|
|
match submission_type:
|
|
case SubmissionType():
|
|
# logger.debug(f"Looking up {cls.__name__} by SubmissionType {submission_type}")
|
|
query = query.filter(cls.submission_type == submission_type)
|
|
case str():
|
|
# logger.debug(f"Looking up {cls.__name__} by name {submission_type}")
|
|
query = query.join(SubmissionType).filter(SubmissionType.name == submission_type)
|
|
case int():
|
|
# logger.debug(f"Looking up {cls.__name__} by id {submission_type}")
|
|
query = query.join(SubmissionType).filter(SubmissionType.id == submission_type)
|
|
match kit_type:
|
|
case KitType():
|
|
# logger.debug(f"Looking up {cls.__name__} by KitType {kit_type}")
|
|
query = query.filter(cls.kit_type == kit_type)
|
|
case str():
|
|
# logger.debug(f"Looking up {cls.__name__} by name {kit_type}")
|
|
query = query.join(KitType).filter(KitType.name == kit_type)
|
|
case int():
|
|
# logger.debug(f"Looking up {cls.__name__} by id {kit_type}")
|
|
query = query.join(KitType).filter(KitType.id == kit_type)
|
|
limit = query.count()
|
|
return cls.execute_query(query=query, limit=limit)
|
|
|
|
def to_export_dict(self):
|
|
exclude = ['_sa_instance_state', 'submission_types_id', 'kits_id', 'submission_type', 'kit_type']
|
|
base_dict = {k: v for k, v in self.__dict__.items() if k not in exclude}
|
|
base_dict['kit_type'] = self.kit_type.to_export_dict(submission_type=self.submission_type)
|
|
logger.debug(f"STKTA returning: {base_dict}")
|
|
return base_dict
|
|
|
|
|
|
class KitTypeReagentRoleAssociation(BaseClass):
|
|
"""
|
|
table containing reagenttype/kittype associations
|
|
DOC: https://docs.sqlalchemy.org/en/14/orm/extensions/associationproxy.html
|
|
"""
|
|
|
|
reagent_roles_id = Column(INTEGER, ForeignKey("_reagentrole.id"),
|
|
primary_key=True) #: id of associated reagent type
|
|
kits_id = Column(INTEGER, ForeignKey("_kittype.id"), primary_key=True) #: id of associated reagent type
|
|
submission_type_id = Column(INTEGER, ForeignKey("_submissiontype.id"), primary_key=True)
|
|
uses = Column(JSON) #: map to location on excel sheets of different submission types
|
|
required = Column(INTEGER) #: whether the reagent type is required for the kit (Boolean 1 or 0)
|
|
last_used = Column(String(32)) #: last used lot number of this type of reagent
|
|
|
|
kit_type = relationship(KitType,
|
|
back_populates="kit_reagentrole_associations") #: relationship to associated KitType
|
|
|
|
# reference to the "ReagentType" object
|
|
reagent_role = relationship(ReagentRole,
|
|
back_populates="reagentrole_kit_associations") #: relationship to associated ReagentType
|
|
|
|
submission_type = relationship(SubmissionType,
|
|
back_populates="submissiontype_kit_rt_associations") #: relationship to associated SubmissionType
|
|
|
|
def __init__(self, kit_type=None, reagent_role=None, uses=None, required=1):
|
|
self.kit_type = kit_type
|
|
self.reagent_role = reagent_role
|
|
self.uses = uses
|
|
self.required = required
|
|
|
|
def __repr__(self) -> str:
|
|
return f"<KitTypeReagentRoleAssociation({self.kit_type} & {self.reagent_role})>"
|
|
|
|
@validates('required')
|
|
def validate_age(self, key, value):
|
|
"""
|
|
Ensures only 1 & 0 used in 'required'
|
|
|
|
Args:
|
|
key (str): name of attribute
|
|
value (_type_): value of attribute
|
|
|
|
Raises:
|
|
ValueError: Raised if bad value given
|
|
|
|
Returns:
|
|
_type_: value
|
|
"""
|
|
if not 0 <= value < 2:
|
|
raise ValueError(f'Invalid required value {value}. Must be 0 or 1.')
|
|
return value
|
|
|
|
@validates('reagentrole')
|
|
def validate_reagentrole(self, key, value):
|
|
"""
|
|
Ensures reagenttype is an actual ReagentType
|
|
|
|
Args:
|
|
key (str)): name of attribute
|
|
value (_type_): value of attribute
|
|
|
|
Raises:
|
|
ValueError: raised if reagenttype is not a ReagentType
|
|
|
|
Returns:
|
|
_type_: ReagentType
|
|
"""
|
|
if not isinstance(value, ReagentRole):
|
|
raise ValueError(f'{value} is not a reagentrole')
|
|
return value
|
|
|
|
@classmethod
|
|
@setup_lookup
|
|
def query(cls,
|
|
kit_type: KitType | str | None = None,
|
|
reagent_role: ReagentRole | str | None = None,
|
|
limit: int = 0
|
|
) -> KitTypeReagentRoleAssociation | List[KitTypeReagentRoleAssociation]:
|
|
"""
|
|
Lookup junction of ReagentType and KitType
|
|
|
|
Args:
|
|
kit_type (models.KitType | str | None): KitType of interest.
|
|
reagent_role (models.ReagentType | str | None): ReagentType of interest.
|
|
limit (int, optional): Maximum number of results to return (0 = all). Defaults to 0.
|
|
|
|
Returns:
|
|
models.KitTypeReagentTypeAssociation|List[models.KitTypeReagentTypeAssociation]: Junction of interest.
|
|
"""
|
|
query: Query = cls.__database_session__.query(cls)
|
|
match kit_type:
|
|
case KitType():
|
|
# logger.debug(f"Lookup KitTypeReagentTypeAssociation by kit_type KitType {kit_type}")
|
|
query = query.filter(cls.kit_type == kit_type)
|
|
case str():
|
|
# logger.debug(f"Lookup KitTypeReagentTypeAssociation by kit_type str {kit_type}")
|
|
query = query.join(KitType).filter(KitType.name == kit_type)
|
|
case _:
|
|
pass
|
|
match reagent_role:
|
|
case ReagentRole():
|
|
# logger.debug(f"Lookup KitTypeReagentTypeAssociation by reagent_type ReagentType {reagent_type}")
|
|
query = query.filter(cls.reagent_role == reagent_role)
|
|
case str():
|
|
# logger.debug(f"Lookup KitTypeReagentTypeAssociation by reagent_type ReagentType {reagent_type}")
|
|
query = query.join(ReagentRole).filter(ReagentRole.name == reagent_role)
|
|
case _:
|
|
pass
|
|
if kit_type is not None and reagent_role is not None:
|
|
limit = 1
|
|
return cls.execute_query(query=query, limit=limit)
|
|
|
|
def to_export_dict(self):
|
|
base_dict = {}
|
|
base_dict['required'] = self.required
|
|
for k, v in self.reagent_role.to_export_dict().items():
|
|
base_dict[k] = v
|
|
return base_dict
|
|
|
|
|
|
class SubmissionReagentAssociation(BaseClass):
|
|
"""
|
|
table containing submission/reagent associations
|
|
DOC: https://docs.sqlalchemy.org/en/14/orm/extensions/associationproxy.html
|
|
"""
|
|
|
|
reagent_id = Column(INTEGER, ForeignKey("_reagent.id"), primary_key=True) #: id of associated reagent
|
|
submission_id = Column(INTEGER, ForeignKey("_basicsubmission.id"), primary_key=True) #: id of associated submission
|
|
comments = Column(String(1024)) #: Comments about reagents
|
|
|
|
submission = relationship("BasicSubmission",
|
|
back_populates="submission_reagent_associations") #: associated submission
|
|
|
|
reagent = relationship(Reagent, back_populates="reagent_submission_associations") #: associated reagent
|
|
|
|
def __repr__(self) -> str:
|
|
"""
|
|
Returns:
|
|
str: Representation of this SubmissionReagentAssociation
|
|
"""
|
|
return f"<{self.submission.rsl_plate_num} & {self.reagent.lot}>"
|
|
|
|
def __init__(self, reagent=None, submission=None):
|
|
if isinstance(reagent, list):
|
|
logger.warning(f"Got list for reagent. Likely no lot was provided. Using {reagent[0]}")
|
|
reagent = reagent[0]
|
|
self.reagent = reagent
|
|
self.submission = submission
|
|
self.comments = ""
|
|
|
|
@classmethod
|
|
@setup_lookup
|
|
def query(cls,
|
|
submission: "BasicSubmission" | str | int | None = None,
|
|
reagent: Reagent | str | None = None,
|
|
limit: int = 0) -> SubmissionReagentAssociation | List[SubmissionReagentAssociation]:
|
|
"""
|
|
Lookup SubmissionReagentAssociations of interest.
|
|
|
|
Args:
|
|
submission (BasicSubmission" | str | int | None, optional): Identifier of joined submission. Defaults to None.
|
|
reagent (Reagent | str | None, optional): Identifier of joined reagent. Defaults to None.
|
|
limit (int, optional): Maximum number of results to return (0 = all). Defaults to 0.
|
|
|
|
Returns:
|
|
SubmissionReagentAssociation|List[SubmissionReagentAssociation]: SubmissionReagentAssociation(s) of interest
|
|
"""
|
|
from . import BasicSubmission
|
|
query: Query = cls.__database_session__.query(cls)
|
|
match reagent:
|
|
case Reagent() | str():
|
|
# logger.debug(f"Lookup SubmissionReagentAssociation by reagent Reagent {reagent}")
|
|
if isinstance(reagent, str):
|
|
reagent = Reagent.query(lot_number=reagent)
|
|
query = query.filter(cls.reagent == reagent)
|
|
case _:
|
|
pass
|
|
match submission:
|
|
case BasicSubmission() | str():
|
|
if isinstance(submission, str):
|
|
# submission = BasicSubmission.query(rsl_number=submission)
|
|
submission = BasicSubmission.query(rsl_plate_num=submission)
|
|
# logger.debug(f"Lookup SubmissionReagentAssociation by submission BasicSubmission {submission}")
|
|
query = query.filter(cls.submission == submission)
|
|
case int():
|
|
# logger.debug(f"Lookup SubmissionReagentAssociation by submission id {submission}")
|
|
submission = BasicSubmission.query(id=submission)
|
|
query = query.join(BasicSubmission).filter(BasicSubmission.id == submission)
|
|
case _:
|
|
pass
|
|
return cls.execute_query(query=query, limit=limit)
|
|
|
|
def to_sub_dict(self, extraction_kit) -> dict:
|
|
"""
|
|
Converts this SubmissionReagentAssociation (and associated Reagent) to dict
|
|
|
|
Args:
|
|
extraction_kit (_type_): Extraction kit of interest
|
|
|
|
Returns:
|
|
dict: This SubmissionReagentAssociation as dict
|
|
"""
|
|
output = self.reagent.to_sub_dict(extraction_kit)
|
|
output['comments'] = self.comments
|
|
return output
|
|
|
|
|
|
class Equipment(BaseClass):
|
|
"""
|
|
A concrete instance of equipment
|
|
"""
|
|
|
|
id = Column(INTEGER, primary_key=True) #: id, primary key
|
|
name = Column(String(64)) #: equipment name
|
|
nickname = Column(String(64)) #: equipment nickname
|
|
asset_number = Column(String(16)) #: Given asset number (corpo nickname if you will)
|
|
roles = relationship("EquipmentRole", back_populates="instances",
|
|
secondary=equipmentroles_equipment) #: relation to EquipmentRoles
|
|
processes = relationship("Process", back_populates="equipment",
|
|
secondary=equipment_processes) #: relation to Processes
|
|
tips = relationship("Tips", back_populates="equipment",
|
|
secondary=equipment_tips) #: relation to Processes
|
|
equipment_submission_associations = relationship(
|
|
"SubmissionEquipmentAssociation",
|
|
back_populates="equipment",
|
|
cascade="all, delete-orphan",
|
|
) #: Association with BasicSubmission
|
|
|
|
submissions = association_proxy("equipment_submission_associations",
|
|
"submission") #: proxy to equipment_submission_associations.submission
|
|
|
|
def __repr__(self) -> str:
|
|
"""
|
|
Returns:
|
|
str: represenation of this Equipment
|
|
"""
|
|
return f"<Equipment({self.name})>"
|
|
|
|
def to_dict(self, processes: bool = False) -> dict:
|
|
"""
|
|
This Equipment as a dictionary
|
|
|
|
Args:
|
|
processes (bool, optional): Whether to include processes. Defaults to False.
|
|
|
|
Returns:
|
|
dict: Dictionary representation of this equipment
|
|
"""
|
|
if not processes:
|
|
return {k: v for k, v in self.__dict__.items() if k != 'processes'}
|
|
else:
|
|
return {k: v for k, v in self.__dict__.items()}
|
|
|
|
def get_processes(self, submission_type: SubmissionType, extraction_kit: str | KitType | None = None) -> List[str]:
|
|
"""
|
|
Get all processes associated with this Equipment for a given SubmissionType
|
|
|
|
Args:
|
|
submission_type (SubmissionType): SubmissionType of interest
|
|
extraction_kit (str | KitType | None, optional): KitType to filter by. Defaults to None.
|
|
|
|
Returns:
|
|
List[Process]: List of process names
|
|
"""
|
|
processes = [process for process in self.processes if submission_type in process.submission_types]
|
|
match extraction_kit:
|
|
case str():
|
|
# logger.debug(f"Filtering processes by extraction_kit str {extraction_kit}")
|
|
processes = [process for process in processes if
|
|
extraction_kit in [kit.name for kit in process.kit_types]]
|
|
case KitType():
|
|
# logger.debug(f"Filtering processes by extraction_kit KitType {extraction_kit}")
|
|
processes = [process for process in processes if extraction_kit in process.kit_types]
|
|
case _:
|
|
pass
|
|
# NOTE: Convert to strings
|
|
processes = [process.name for process in processes]
|
|
assert all([isinstance(process, str) for process in processes])
|
|
if len(processes) == 0:
|
|
processes = ['']
|
|
return processes
|
|
|
|
@classmethod
|
|
@setup_lookup
|
|
def query(cls,
|
|
name: str | None = None,
|
|
nickname: str | None = None,
|
|
asset_number: str | None = None,
|
|
limit: int = 0
|
|
) -> Equipment | List[Equipment]:
|
|
"""
|
|
Lookup a list of or single Equipment.
|
|
|
|
Args:
|
|
name (str | None, optional): Equipment name. Defaults to None.
|
|
nickname (str | None, optional): Equipment nickname. Defaults to None.
|
|
asset_number (str | None, optional): Equipment asset number. Defaults to None.
|
|
limit (int, optional): Maximum number of results to return (0 = all). Defaults to 0.
|
|
|
|
Returns:
|
|
Equipment|List[Equipment]: Equipment or list of equipment matching query parameters.
|
|
"""
|
|
query = cls.__database_session__.query(cls)
|
|
match name:
|
|
case str():
|
|
# logger.debug(f"Lookup Equipment by name str {name}")
|
|
query = query.filter(cls.name == name)
|
|
limit = 1
|
|
case _:
|
|
pass
|
|
match nickname:
|
|
case str():
|
|
# logger.debug(f"Lookup Equipment by nickname str {nickname}")
|
|
query = query.filter(cls.nickname == nickname)
|
|
limit = 1
|
|
case _:
|
|
pass
|
|
match asset_number:
|
|
case str():
|
|
# logger.debug(f"Lookup Equipment by asset_number str {asset_number}")
|
|
query = query.filter(cls.asset_number == asset_number)
|
|
limit = 1
|
|
case _:
|
|
pass
|
|
return cls.execute_query(query=query, limit=limit)
|
|
|
|
def to_pydantic(self, submission_type: SubmissionType,
|
|
extraction_kit: str | KitType | None = None,
|
|
role: str = None) -> "PydEquipment":
|
|
"""
|
|
Creates PydEquipment of this Equipment
|
|
|
|
Args:
|
|
submission_type (SubmissionType): Relevant SubmissionType
|
|
extraction_kit (str | KitType | None, optional): Relevant KitType. Defaults to None.
|
|
|
|
Returns:
|
|
PydEquipment: pydantic equipment object
|
|
"""
|
|
from backend.validators.pydant import PydEquipment
|
|
return PydEquipment(
|
|
processes=self.get_processes(submission_type=submission_type, extraction_kit=extraction_kit), role=role,
|
|
**self.to_dict(processes=False))
|
|
|
|
@classmethod
|
|
def get_regex(cls) -> re.Pattern:
|
|
"""
|
|
Creates regex to determine tip manufacturer
|
|
|
|
Returns:
|
|
re.Pattern: regex
|
|
"""
|
|
return re.compile(r"""
|
|
(?P<PHAC>50\d{5}$)|
|
|
(?P<HC>HC-\d{6}$)|
|
|
(?P<Beckman>[^\d][A-Z0-9]{6}$)|
|
|
(?P<Axygen>[A-Z]{3}-\d{2}-[A-Z]-[A-Z]$)|
|
|
(?P<Labcon>\d{4}-\d{3}-\d{3}-\d$)""",
|
|
re.VERBOSE)
|
|
|
|
|
|
class EquipmentRole(BaseClass):
|
|
"""
|
|
Abstract roles for equipment
|
|
"""
|
|
|
|
id = Column(INTEGER, primary_key=True) #: Role id, primary key
|
|
name = Column(String(32)) #: Common name
|
|
instances = relationship("Equipment", back_populates="roles",
|
|
secondary=equipmentroles_equipment) #: Concrete instances (Equipment) of role
|
|
processes = relationship("Process", back_populates='equipment_roles',
|
|
secondary=equipmentroles_processes) #: Associated Processes
|
|
|
|
equipmentrole_submissiontype_associations = relationship(
|
|
"SubmissionTypeEquipmentRoleAssociation",
|
|
back_populates="equipment_role",
|
|
cascade="all, delete-orphan",
|
|
) #: relation to SubmissionTypes
|
|
|
|
submission_types = association_proxy("equipmentrole_submissiontype_associations",
|
|
"submission_type") #: proxy to equipmentrole_submissiontype_associations.submission_type
|
|
|
|
def __repr__(self) -> str:
|
|
"""
|
|
Returns:
|
|
str: Representation of this EquipmentRole
|
|
"""
|
|
return f"<EquipmentRole({self.name})>"
|
|
|
|
def to_dict(self) -> dict:
|
|
"""
|
|
This EquipmentRole as a dictionary
|
|
|
|
Returns:
|
|
dict: This EquipmentRole dict
|
|
"""
|
|
# output = {}
|
|
return {key: value for key, value in self.__dict__.items() if key != "processes"}
|
|
# match key:
|
|
# case "processes":
|
|
# pass
|
|
# case _:
|
|
# value = value
|
|
# yield key, value
|
|
# # output[key] = value
|
|
# return output
|
|
|
|
def to_pydantic(self, submission_type: SubmissionType,
|
|
extraction_kit: str | KitType | None = None) -> "PydEquipmentRole":
|
|
"""
|
|
Creates a PydEquipmentRole of this EquipmentRole
|
|
|
|
Args:
|
|
submission_type (SubmissionType): SubmissionType of interest
|
|
extraction_kit (str | KitType | None, optional): KitType of interest. Defaults to None.
|
|
|
|
Returns:
|
|
PydEquipmentRole: This EquipmentRole as PydEquipmentRole
|
|
"""
|
|
from backend.validators.pydant import PydEquipmentRole
|
|
# logger.debug("Creating list of PydEquipment in this role")
|
|
equipment = [item.to_pydantic(submission_type=submission_type, extraction_kit=extraction_kit) for item in
|
|
self.instances]
|
|
pyd_dict = self.to_dict()
|
|
# logger.debug("Creating list of Processes in this role")
|
|
pyd_dict['processes'] = self.get_processes(submission_type=submission_type, extraction_kit=extraction_kit)
|
|
return PydEquipmentRole(equipment=equipment, **pyd_dict)
|
|
|
|
@classmethod
|
|
@setup_lookup
|
|
def query(cls, name: str | None = None, id: int | None = None, limit: int = 0) -> EquipmentRole | List[
|
|
EquipmentRole]:
|
|
"""
|
|
Lookup Equipment roles.
|
|
|
|
Args:
|
|
name (str | None, optional): EquipmentRole name. Defaults to None.
|
|
id (int | None, optional): EquipmentRole id. Defaults to None.
|
|
limit (int, optional): Maximum number of results to return (0 = all). Defaults to 0.
|
|
|
|
Returns:
|
|
EquipmentRole|List[EquipmentRole]: List of EquipmentRoles matching criteria
|
|
"""
|
|
query = cls.__database_session__.query(cls)
|
|
match id:
|
|
case int():
|
|
# logger.debug(f"Lookup EquipmentRole by id {id}")
|
|
query = query.filter(cls.id == id)
|
|
limit = 1
|
|
case _:
|
|
pass
|
|
match name:
|
|
case str():
|
|
# logger.debug(f"Lookup EquipmentRole by name str {name}")
|
|
query = query.filter(cls.name == name)
|
|
limit = 1
|
|
case _:
|
|
pass
|
|
return cls.execute_query(query=query, limit=limit)
|
|
|
|
def get_processes(self, submission_type: str | SubmissionType | None,
|
|
extraction_kit: str | KitType | None = None) -> List[Process]:
|
|
"""
|
|
Get processes used by this EquipmentRole
|
|
|
|
Args:
|
|
submission_type (str | SubmissionType | None): SubmissionType of interest
|
|
extraction_kit (str | KitType | None, optional): KitType of interest. Defaults to None.
|
|
|
|
Returns:
|
|
List[Process]: _description_
|
|
"""
|
|
if isinstance(submission_type, str):
|
|
# logger.debug(f"Checking if str {submission_type} exists")
|
|
submission_type = SubmissionType.query(name=submission_type)
|
|
if submission_type is not None:
|
|
# logger.debug("Getting all processes for this EquipmentRole")
|
|
processes = [process for process in self.processes if submission_type in process.submission_types]
|
|
else:
|
|
processes = self.processes
|
|
match extraction_kit:
|
|
case str():
|
|
# logger.debug(f"Filtering processes by extraction_kit str {extraction_kit}")
|
|
processes = [item for item in processes if extraction_kit in [kit.name for kit in item.kit_types]]
|
|
case KitType():
|
|
# logger.debug(f"Filtering processes by extraction_kit KitType {extraction_kit}")
|
|
processes = [item for item in processes if extraction_kit in [kit for kit in item.kit_types]]
|
|
case _:
|
|
pass
|
|
output = [item.name for item in processes]
|
|
if len(output) == 0:
|
|
return ['']
|
|
else:
|
|
return output
|
|
|
|
def to_export_dict(self, submission_type: SubmissionType, kit_type: KitType):
|
|
base_dict = {}
|
|
base_dict['role'] = self.name
|
|
base_dict['processes'] = self.get_processes(submission_type=submission_type, extraction_kit=kit_type)
|
|
return base_dict
|
|
|
|
|
|
class SubmissionEquipmentAssociation(BaseClass):
|
|
"""
|
|
Abstract association between BasicSubmission and Equipment
|
|
"""
|
|
|
|
equipment_id = Column(INTEGER, ForeignKey("_equipment.id"), primary_key=True) #: id of associated equipment
|
|
submission_id = Column(INTEGER, ForeignKey("_basicsubmission.id"), primary_key=True) #: id of associated submission
|
|
role = Column(String(64), primary_key=True) #: name of the role the equipment fills
|
|
process_id = Column(INTEGER, ForeignKey("_process.id", ondelete="SET NULL",
|
|
name="SEA_Process_id")) #: Foreign key of process id
|
|
start_time = Column(TIMESTAMP) #: start time of equipment use
|
|
end_time = Column(TIMESTAMP) #: end time of equipment use
|
|
comments = Column(String(1024)) #: comments about equipment
|
|
|
|
submission = relationship("BasicSubmission",
|
|
back_populates="submission_equipment_associations") #: associated submission
|
|
|
|
equipment = relationship(Equipment, back_populates="equipment_submission_associations") #: associated equipment
|
|
|
|
def __repr__(self):
|
|
return f"<SubmissionEquipmentAssociation({self.submission.rsl_plate_num} & {self.equipment.name})>"
|
|
|
|
def __init__(self, submission, equipment, role: str = "None"):
|
|
self.submission = submission
|
|
self.equipment = equipment
|
|
self.role = role
|
|
|
|
def to_sub_dict(self) -> dict:
|
|
"""
|
|
This SubmissionEquipmentAssociation as a dictionary
|
|
|
|
Returns:
|
|
dict: This SubmissionEquipmentAssociation as a dictionary
|
|
"""
|
|
try:
|
|
process = self.process.name
|
|
except AttributeError:
|
|
process = "No process found"
|
|
output = dict(name=self.equipment.name, asset_number=self.equipment.asset_number, comment=self.comments,
|
|
processes=[process], role=self.role, nickname=self.equipment.nickname)
|
|
return output
|
|
|
|
@classmethod
|
|
@setup_lookup
|
|
def query(cls, equipment_id: int, submission_id: int, role: str | None = None, limit: int = 0, **kwargs) -> Any | \
|
|
List[
|
|
Any]:
|
|
query: Query = cls.__database_session__.query(cls)
|
|
query = query.filter(cls.equipment_id == equipment_id)
|
|
query = query.filter(cls.submission_id == submission_id)
|
|
if role is not None:
|
|
query = query.filter(cls.role == role)
|
|
return cls.execute_query(query=query, limit=limit, **kwargs)
|
|
|
|
|
|
class SubmissionTypeEquipmentRoleAssociation(BaseClass):
|
|
"""
|
|
Abstract association between SubmissionType and EquipmentRole
|
|
"""
|
|
equipmentrole_id = Column(INTEGER, ForeignKey("_equipmentrole.id"), primary_key=True) #: id of associated equipment
|
|
submissiontype_id = Column(INTEGER, ForeignKey("_submissiontype.id"),
|
|
primary_key=True) #: id of associated submission
|
|
uses = Column(JSON) #: locations of equipment on the submission type excel sheet.
|
|
static = Column(INTEGER,
|
|
default=1) #: if 1 this piece of equipment will always be used, otherwise it will need to be selected from list?
|
|
|
|
submission_type = relationship(SubmissionType,
|
|
back_populates="submissiontype_equipmentrole_associations") #: associated submission
|
|
|
|
equipment_role = relationship(EquipmentRole,
|
|
back_populates="equipmentrole_submissiontype_associations") #: associated equipment
|
|
|
|
@validates('static')
|
|
def validate_static(self, key, value):
|
|
"""
|
|
Ensures only 1 & 0 used in 'static'
|
|
|
|
Args:
|
|
key (str): name of attribute
|
|
value (_type_): value of attribute
|
|
|
|
Raises:
|
|
ValueError: Raised if bad value given
|
|
|
|
Returns:
|
|
_type_: value
|
|
"""
|
|
if not 0 <= value < 2:
|
|
raise ValueError(f'Invalid required value {value}. Must be 0 or 1.')
|
|
return value
|
|
|
|
def get_all_processes(self, extraction_kit: KitType | str | None = None) -> List[Process]:
|
|
"""
|
|
Get all processes associated with this SubmissionTypeEquipmentRole
|
|
|
|
Args:
|
|
extraction_kit (KitType | str | None, optional): KitType of interest. Defaults to None.
|
|
|
|
Returns:
|
|
List[Process]: All associated processes
|
|
"""
|
|
processes = [equipment.get_processes(self.submission_type) for equipment in self.equipment_role.instances]
|
|
# NOTE: flatten list
|
|
processes = [item for items in processes for item in items if item is not None]
|
|
match extraction_kit:
|
|
case str():
|
|
# logger.debug(f"Filtering Processes by extraction_kit str {extraction_kit}")
|
|
processes = [item for item in processes if extraction_kit in [kit.name for kit in item.kit_type]]
|
|
case KitType():
|
|
# logger.debug(f"Filtering Processes by extraction_kit KitType {extraction_kit}")
|
|
processes = [item for item in processes if extraction_kit in [kit for kit in item.kit_type]]
|
|
case _:
|
|
pass
|
|
return processes
|
|
|
|
@check_authorization
|
|
def save(self):
|
|
super().save()
|
|
|
|
def to_export_dict(self, kit_type: KitType):
|
|
base_dict = dict(static=self.static)
|
|
for k, v in self.equipment_role.to_export_dict(submission_type=self.submission_type, kit_type=kit_type).items():
|
|
base_dict[k] = v
|
|
return base_dict
|
|
|
|
|
|
class Process(BaseClass):
|
|
"""
|
|
A Process is a method used by a piece of equipment.
|
|
"""
|
|
|
|
id = Column(INTEGER, primary_key=True) #: Process id, primary key
|
|
name = Column(String(64), unique=True) #: Process name
|
|
submission_types = relationship("SubmissionType", back_populates='processes',
|
|
secondary=submissiontypes_processes) #: relation to SubmissionType
|
|
equipment = relationship("Equipment", back_populates='processes',
|
|
secondary=equipment_processes) #: relation to Equipment
|
|
equipment_roles = relationship("EquipmentRole", back_populates='processes',
|
|
secondary=equipmentroles_processes) #: relation to EquipmentRoles
|
|
submissions = relationship("SubmissionEquipmentAssociation",
|
|
backref='process') #: relation to SubmissionEquipmentAssociation
|
|
kit_types = relationship("KitType", back_populates='processes',
|
|
secondary=kittypes_processes) #: relation to KitType
|
|
tip_roles = relationship("TipRole", back_populates='processes',
|
|
secondary=process_tiprole) #: relation to KitType
|
|
|
|
def __repr__(self) -> str:
|
|
"""
|
|
Returns:
|
|
str: Representation of this Process
|
|
"""
|
|
return f"<Process({self.name})>"
|
|
|
|
@classmethod
|
|
@setup_lookup
|
|
def query(cls,
|
|
name: str | None = None,
|
|
id: int | None = None,
|
|
limit: int = 0) -> Process | List[Process]:
|
|
"""
|
|
Lookup Processes
|
|
|
|
Args:
|
|
id (int | None, optional): Process id. Defaults to None.
|
|
name (str | None, optional): Process name. Defaults to None.
|
|
limit (int, optional): Maximum number of results to return (0=all). Defaults to 0.
|
|
|
|
Returns:
|
|
Process|List[Process]: Process(es) matching criteria
|
|
"""
|
|
query = cls.__database_session__.query(cls)
|
|
match name:
|
|
case str():
|
|
# logger.debug(f"Lookup Process with name str {name}")
|
|
query = query.filter(cls.name == name)
|
|
limit = 1
|
|
case _:
|
|
pass
|
|
match id:
|
|
case int():
|
|
query = query.filter(cls.id == id)
|
|
limit = 1
|
|
case _:
|
|
pass
|
|
return cls.execute_query(query=query, limit=limit)
|
|
|
|
@check_authorization
|
|
def save(self):
|
|
super().save()
|
|
|
|
|
|
class TipRole(BaseClass):
|
|
"""
|
|
An abstract role that a tip fills during a process
|
|
"""
|
|
id = Column(INTEGER, primary_key=True) #: primary key
|
|
name = Column(String(64)) #: name of reagent type
|
|
instances = relationship("Tips", back_populates="role",
|
|
secondary=tiproles_tips) #: concrete instances of this reagent type
|
|
processes = relationship("Process", back_populates="tip_roles", secondary=process_tiprole)
|
|
|
|
tiprole_submissiontype_associations = relationship(
|
|
"SubmissionTypeTipRoleAssociation",
|
|
back_populates="tip_role",
|
|
cascade="all, delete-orphan"
|
|
) #: associated submission
|
|
|
|
submission_types = association_proxy("tiprole_submissiontype_associations", "submission_type")
|
|
|
|
def __repr__(self):
|
|
return f"<TipRole({self.name})>"
|
|
|
|
@check_authorization
|
|
def save(self):
|
|
super().save()
|
|
|
|
|
|
class Tips(BaseClass):
|
|
"""
|
|
A concrete instance of tips.
|
|
"""
|
|
id = Column(INTEGER, primary_key=True) #: primary key
|
|
role = relationship("TipRole", back_populates="instances",
|
|
secondary=tiproles_tips) #: joined parent reagent type
|
|
role_id = Column(INTEGER, ForeignKey("_tiprole.id", ondelete='SET NULL',
|
|
name="fk_tip_role_id")) #: id of parent reagent type
|
|
name = Column(String(64)) #: tip common name
|
|
lot = Column(String(64)) #: lot number of tips
|
|
equipment = relationship("Equipment", back_populates="tips",
|
|
secondary=equipment_tips) #: associated submission
|
|
tips_submission_associations = relationship(
|
|
"SubmissionTipsAssociation",
|
|
back_populates="tips",
|
|
cascade="all, delete-orphan"
|
|
) #: associated submission
|
|
|
|
submissions = association_proxy("tips_submission_associations", 'submission')
|
|
|
|
def __repr__(self):
|
|
return f"<Tips({self.name})>"
|
|
|
|
@classmethod
|
|
def query(cls, name: str | None = None, lot: str | None = None, limit: int = 0, **kwargs) -> Tips | List[Tips]:
|
|
"""
|
|
Lookup tips
|
|
|
|
Args:
|
|
name (str | None, optional): Informal name of tips. Defaults to None.
|
|
lot (str | None, optional): Lot number. Defaults to None.
|
|
limit (int, optional): Maximum number of results to return (0=all). Defaults to 0.
|
|
|
|
Returns:
|
|
Tips | List[Tips]: Tips matching criteria
|
|
"""
|
|
query = cls.__database_session__.query(cls)
|
|
match name:
|
|
case str():
|
|
# logger.debug(f"Lookup Equipment by name str {name}")
|
|
query = query.filter(cls.name == name)
|
|
case _:
|
|
pass
|
|
match lot:
|
|
case str():
|
|
# logger.debug(f"Lookup Equipment by nickname str {nickname}")
|
|
query = query.filter(cls.lot == lot)
|
|
limit = 1
|
|
case _:
|
|
pass
|
|
return cls.execute_query(query=query, limit=limit)
|
|
|
|
@check_authorization
|
|
def save(self):
|
|
super().save()
|
|
|
|
|
|
class SubmissionTypeTipRoleAssociation(BaseClass):
|
|
"""
|
|
Abstract association between SubmissionType and TipRole
|
|
"""
|
|
tiprole_id = Column(INTEGER, ForeignKey("_tiprole.id"), primary_key=True) #: id of associated equipment
|
|
submissiontype_id = Column(INTEGER, ForeignKey("_submissiontype.id"),
|
|
primary_key=True) #: id of associated submission
|
|
uses = Column(JSON) #: locations of equipment on the submission type excel sheet.
|
|
static = Column(INTEGER,
|
|
default=1) #: if 1 this piece of equipment will always be used, otherwise it will need to be selected from list?
|
|
submission_type = relationship(SubmissionType,
|
|
back_populates="submissiontype_tiprole_associations") #: associated submission
|
|
tip_role = relationship(TipRole,
|
|
back_populates="tiprole_submissiontype_associations") #: associated equipment
|
|
|
|
@check_authorization
|
|
def save(self):
|
|
super().save()
|
|
|
|
|
|
class SubmissionTipsAssociation(BaseClass):
|
|
"""
|
|
Association between a concrete submission instance and concrete tips
|
|
"""
|
|
tip_id = Column(INTEGER, ForeignKey("_tips.id"), primary_key=True) #: id of associated equipment
|
|
submission_id = Column(INTEGER, ForeignKey("_basicsubmission.id"), primary_key=True) #: id of associated submission
|
|
submission = relationship("BasicSubmission",
|
|
back_populates="submission_tips_associations") #: associated submission
|
|
tips = relationship(Tips,
|
|
back_populates="tips_submission_associations") #: associated equipment
|
|
role_name = Column(String(32), primary_key=True) #, ForeignKey("_tiprole.name"))
|
|
|
|
def to_sub_dict(self) -> dict:
|
|
"""
|
|
This item as a dictionary
|
|
|
|
Returns:
|
|
dict: Values of this object
|
|
"""
|
|
return dict(role=self.role_name, name=self.tips.name, lot=self.tips.lot)
|
|
|
|
@classmethod
|
|
@setup_lookup
|
|
def query(cls, tip_id: int, role: str, submission_id: int | None = None, limit: int = 0, **kwargs) -> Any | List[
|
|
Any]:
|
|
query: Query = cls.__database_session__.query(cls)
|
|
query = query.filter(cls.tip_id == tip_id)
|
|
if submission_id is not None:
|
|
query = query.filter(cls.submission_id == submission_id)
|
|
query = query.filter(cls.role_name == role)
|
|
return cls.execute_query(query=query, limit=limit, **kwargs)
|