def microbial_store(base_store: Store, microbial_submitted_order):
"""Setup a store instance for testing analysis API."""
customer = base_store.customer(microbial_submitted_order["customer"])
for sample_data in microbial_submitted_order["items"]:
application_version = base_store.application(
sample_data["application"]).versions[0]
organism = base_store.Organism(internal_id=sample_data["organism"],
name=sample_data["organism"])
base_store.add(organism)
sample = base_store.add_sample(
comment=sample_data["comment"],
name=sample_data["name"],
priority=sample_data["priority"],
reads=sample_data["reads"],
reference_genome=sample_data["reference_genome"],
sex="unknown",
ticket=microbial_submitted_order["ticket_number"],
)
sample.application_version = application_version
sample.customer = customer
sample.organism = organism
base_store.add(sample)
base_store.commit()
yield base_store
def import_applications(
store: Store, excel_path: str, sign: str, dry_run: bool, sheet_name: Optional[str] = None
):
"""
Imports all applications from the specified excel file
Args:
:param sheet_name: Optional sheet name
:param store: status database store
:param excel_path: Path to excel file with headers: 'App tag', 'Valid from',
'Standard', 'Priority', 'Express', 'Research'
:param sign: Signature of user running the script
:param dry_run: Test run, no changes to the database
"""
applications: Iterable[ApplicationSchema] = parse_applications(
excel_path=excel_path, sheet_name=sheet_name
)
for application in applications:
application_obj: models.Application = store.application(application.tag)
if application_obj and applications_are_same(
application_obj=application_obj, application=application
):
LOG.info("skipping redundant application %s", application.tag)
continue
LOG.info("adding new application to transaction %s", application.tag)
new_application = add_application_object(application=application, sign=sign, store=store)
store.add(new_application)
if not dry_run:
LOG.info("all applications successfully added to transaction, committing transaction")
store.commit()
else:
LOG.error("Dry-run, rolling back transaction.")
store.rollback()
def flowcell_store(base_store: Store, data: dict) -> Store:
"""Setup store with sample data for testing flowcell transfer."""
for sample_data in data["samples"]:
customer_obj: models.Customer = base_store.customers().first()
application_version: models.ApplicationVersion = base_store.application(
"WGSPCFC030").versions[0]
sample: models.Sample = base_store.add_sample(
name="NA", sex="male", internal_id=sample_data["name"])
sample.customer = customer_obj
sample.application_version = application_version
sample.received_at = dt.datetime.now()
base_store.add(sample)
base_store.commit()
yield base_store
def fixture_analysis_store(base_store: Store, analysis_family: dict) -> Store:
"""Setup a store instance for testing analysis API."""
customer = base_store.customer("cust000")
family = base_store.Family(
data_analysis=analysis_family["data_analysis"],
name=analysis_family["name"],
panels=analysis_family["panels"],
internal_id=analysis_family["internal_id"],
priority=Priority.standard.name,
)
family.customer = customer
base_store.add(family)
application_version = base_store.application("WGSPCFC030").versions[0]
for sample_data in analysis_family["samples"]:
sample = base_store.add_sample(
name=sample_data["name"],
sex=sample_data["sex"],
internal_id=sample_data["internal_id"],
ticket=sample_data["ticket_number"],
reads=sample_data["reads"],
capture_kit=sample_data["capture_kit"],
)
sample.family = family
sample.application_version = application_version
sample.customer = customer
base_store.add(sample)
base_store.commit()
for sample_data in analysis_family["samples"]:
sample_obj = base_store.sample(sample_data["internal_id"])
link = base_store.relate_sample(
family=family,
sample=sample_obj,
status=sample_data["status"],
father=base_store.sample(sample_data["father"])
if sample_data.get("father") else None,
mother=base_store.sample(sample_data["mother"])
if sample_data.get("mother") else None,
)
base_store.add(link)
base_store.commit()
yield base_store
def import_application_versions(
store: Store, excel_path: str, sign: str, dry_run: bool, skip_missing: bool
):
"""
Imports all application versions from the specified excel file
Args:
:param store: Status database store
:param excel_path: Path to excel file with headers: 'App tag', 'Valid from',
'Standard', 'Priority', 'Express', 'Research'
:param sign: Signature of user running the script
:param dry_run: Test run, no changes to the database
:param skip_missing: Continue despite missing applications
"""
application_versions: Iterable[ParsedApplicationVersion] = parse_application_versions(
excel_path=excel_path
)
for application_version in application_versions:
application_obj: models.Application = store.application(application_version.app_tag)
if not application_obj:
LOG.error(
"Failed to find application! Please manually add application: %s",
application_version.app_tag,
)
if skip_missing:
continue
LOG.error("Rolling back transaction.")
store.rollback()
sys.exit()
app_tag: str = application_obj.tag
latest_version: models.ApplicationVersion = store.latest_version(
application_version.app_tag
)
if latest_version and versions_are_same(
version_obj=latest_version, application_version=application_version
):
LOG.info("skipping redundant application version for app tag %s", app_tag)
continue
LOG.info("adding new application version to transaction for app tag %s", app_tag)
new_version = add_application_version(
application_obj=application_obj,
latest_version=latest_version,
version=application_version,
sign=sign,
store=store,
)
store.add(new_version)
if not dry_run:
LOG.info(
"all application versions successfully added to transaction, committing " "transaction"
)
store.commit()
else:
LOG.error("Dry-run, rolling back transaction.")
store.rollback()
