for lane in dataset['sequence_lanes']:
lane_set.add(str(lane['flowcell_id'] + "_" + str(lane['lane_number'])))
analysis_lane_dict[analysis['name']] = lane_set
print analysis_lane_dict
for analysis in colossus_analyses:
key = analysis['analysis_jira_ticket'] + '_align'
if key in analysis_lane_dict.keys():
lanes = []
print "ID" + str(analysis['id'])
for lane in analysis_lane_dict[key]:
try:
print "Getting lane: " + lane
colossus_api.get('lane', flow_cell_id=lane)
lanes.append(colossus_api.get('lane',flow_cell_id=lane)['id'])
except Exception,e:
try:
print e
print "Creating lane: " + lane
for sequencing in analysis['library']['dlpsequencing_set']:
print "Sequence ID" + str(sequencing['id'])
for flow_lane in sequencing['dlplane_set']:
print "Lane ID: " + flow_lane['flow_cell_id']
if flow_lane['flow_cell_id'] == lane[:-2]:
print "ID: " + str(sequencing['id'])
colossus_api.get_or_create('lane', flow_cell_id=lane, path_to_archive="", sequencing=sequencing['id'])
break
print "New ID: " + str(colossus_api.get('lane', flow_cell_id=lane)['id'])
def main(storage_name,
dlp_library_id=None,
internal_id=None,
tag_name=None,
all=False,
update=False,
check_library=False,
dry_run=False):
# Set up the root logger
logging.basicConfig(format=LOGGING_FORMAT,
stream=sys.stderr,
level=logging.INFO)
# Connect to the Tantalus API (this requires appropriate environment)
colossus_api = ColossusApi()
tantalus_api = TantalusApi()
# initiate arrays to store successful and failed libraries
successful_libs = []
failed_libs = []
storage = tantalus_api.get("storage", name=storage_name)
sequencing_list = list()
if dry_run:
logging.info("This is a dry run. No lanes will be imported.")
# Importing a single library
if dlp_library_id is not None:
sequencing_list = list(
colossus_api.list('sequencing',
sequencing_center='BCCAGSC',
library__pool_id=dlp_library_id))
# importing all libraries from the gsc
elif all:
sequencing_list = list(
colossus_api.list('sequencing', sequencing_center='BCCAGSC'))
# importing only sequencing expecting more lanes
else:
sequencing_list = list(
colossus_api.list('sequencing', sequencing_center='BCCAGSC'))
sequencing_list = list(
filter(
lambda s: s['number_of_lanes_requested'] != len(s[
'dlplane_set']), sequencing_list))
for sequencing in sequencing_list:
# import library
try:
import_info = import_gsc_dlp_paired_fastqs(
colossus_api,
tantalus_api,
sequencing,
storage,
internal_id,
tag_name,
update=update,
check_library=check_library,
dry_run=dry_run,
)
# check if no import information exists, if so, library does not exist on GSC
if import_info is None:
lane_requested_date = sequencing["lane_requested_date"]
failed_libs.append(
dict(
dlp_library_id=sequencing["library"],
gsc_library_id="None",
lane_requested_date=lane_requested_date,
error="Doesn't exist on GSC",
))
continue
# check if library excluded from import
elif import_info is False:
continue
# update lanes in sequencing
update_colossus_lane(colossus_api, sequencing,
import_info['lanes'])
# get sequencing object again since sequencing may have with new info
updated_sequencing = colossus_api.get("sequencing",
id=sequencing["id"])
# check if lanes have been imported
check_lanes(colossus_api, updated_sequencing,
len(updated_sequencing["dlplane_set"]))
# add lane_requested_date to import info for import status report
import_info['lane_requested_date'] = sequencing[
'lane_requested_date']
# add library to list of succesfully imported libraries
successful_libs.append(import_info)
# create jira ticket and analyses with new lanes and datasets
create_tickets_and_analyses(import_info)
except Exception as e:
# add lane_requested_date to import info for import status report
lane_requested_date = sequencing["lane_requested_date"]
updated_sequencing = colossus_api.get("sequencing",
id=sequencing["id"])
# add library to list of libraries that failed to import
failed_libs.append(
dict(
dlp_library_id=sequencing["library"],
gsc_library_id=updated_sequencing["gsc_library_id"],
lane_requested_date=lane_requested_date,
error=str(e),
))
logging.exception(
f"Library {sequencing['library']} failed to import: {e}")
continue
# Only write import statuses for bulk imports
if all or dlp_library_id is None:
# Sort lists by date in descending order
successful_libs.sort(
key=lambda x: datetime.datetime.strptime(x['lane_requested_date'],
'%Y-%m-%d'),
reverse=True,
)
failed_libs.sort(
key=lambda x: datetime.datetime.strptime(x['lane_requested_date'],
'%Y-%m-%d'),
reverse=True,
)
# write import report
write_import_statuses(successful_libs, failed_libs)