def update(session: FileOperator, name: str, hardware: str, package: str, definition: dict): device = Device.get(session, name) device.hardware = hardware device.package = package device.definition = definition session.commit()
def update_progname(session: FileOperator, old_prog_name: str, new_prog_name: str): progs = Sequence.get_for_program(session, old_prog_name) for p in progs: p.prog_name = new_prog_name session.commit() # Hacky: Since this used to be done by means of sqlite which would # just delete everything it finds, we eat the exceptions here... try: session.rename(Types.Sequence(), old_prog_name, f"{new_prog_name}_tmp") except: pass try: session.rename(Types.Sequence(), new_prog_name, f"{old_prog_name}_tmp") except: pass try: session.rename(Types.Sequence(), f"{new_prog_name}_tmp", new_prog_name) except: pass try: session.rename(Types.Sequence(), f"{old_prog_name}_tmp", old_prog_name) except: pass
def update(session: FileOperator, name: str, hardware: str, base: str, type: str, definition: dict, is_enabled: bool): test = session.query(Types.Test())\ .filter(lambda Test: (Test.name == name and Test.hardware == hardware and Test.base == base))\ .one() test.definition = definition test.is_enabled = is_enabled session.commit()
def add(session: FileOperator, name: str, device: str, hardware: str, quality: str, grade: str, grade_reference: str, type: str, customer: str, is_enabled=True): # existing_products = Product.get_all(session) # if name in existing_products: # raise KeyError(f"product '{name}' already exists") product = { "name": name, "device": device, "hardware": hardware, "is_enabled": is_enabled, "grade": grade, "quality": quality, "grade_reference": grade_reference, "type": type, "customer": customer } session.query(Types.Product()) session.add(product) session.commit()
def update(session: FileOperator, name: str, leads: int, is_naked_die: bool, is_enabled=True): package = session.query(Types.Package())\ .filter(lambda package: package.name == name)\ .one() package.leads = leads package.is_naked_die = is_naked_die package.is_enabled = is_enabled session.commit()
def update_program_order_and_name(session: FileOperator, new_name: str, new_order: int, owner_name: str, current_order: str): prog = Program.get_by_order_and_owner(session, current_order, owner_name) prog.prog_name = new_name prog.prog_order = new_order session.commit()
def _update_program_order(session: FileOperator, owner_name: str, prev_order: int, order: int, new_name: str): prog = session.query(Types.Program())\ .filter(lambda Program: (Program.owner_name == owner_name and Program.prog_order == prev_order))\ .one() prog.prog_name = new_name prog.prog_order = order session.commit()
def update_changed_state_test_targets(session: FileOperator, hardware: str, base: str, prog_name: str) -> list: tests = session.query(Types.Testtarget())\ .filter(lambda TestTarget: (TestTarget.prog_name == prog_name and TestTarget.hardware == hardware and TestTarget.base == base))\ .all() for test in tests: test.is_changed = False session.commit()
def add_or_update_qualification_flow_data(session: FileOperator, quali_flow_data: DBObject): item = QualificationFlowDatum._get_by_name( session, quali_flow_data.read_attribute("name")) if item is not None: session.filter(lambda x: x.name == item.name).delete() session.add(quali_flow_data.to_dict()) session.commit()
def add(session: FileOperator, name: str, customer: str, definition: dict, is_enabled: bool): maskset = { "name": name, "customer": customer, "definition": definition, "is_enabled": is_enabled } session.query(Types.Maskset()).add(maskset) session.commit()
def add_sequence_information(session: FileOperator, owner_name: str, prog_name: str, test: str, order: int, definition: dict): s = { "owner_name": owner_name, "prog_name": prog_name, "test": test, "test_order": order, "definition": definition } session.query_with_subtype(Types.Sequence(), prog_name).add(s) session.commit()
def add(session: FileOperator, name: str, hardware: str, package: str, definition: dict, is_enabled: bool): # ToDo: implement constraints, i.e. hardware should exist device = { "name": name, "hardware": hardware, "package": package, "definition": definition, "is_enabled": is_enabled } session.query(Types.Device()).add(device) session.commit()
def update(session: FileOperator, name: str, hardware: str, maskset: str, quality: str, grade: str, grade_reference: str, type: str, customer: str): die = Die.get(session, name) die.hardware = hardware die.maskset = maskset die.quality = quality die.grade = grade die.grade_reference = grade_reference die.type = type die.customer = customer session.commit()
def update(session: FileOperator, name: str, hardware: str, base: str, target: str, usertext: str, sequencer_type: str, temperature: str, owner_name: str, cache_type: str, caching_policy: str): prog = Program.get_by_name_and_owner(session, name, owner_name) prog.hardware = hardware prog.base = base prog.target = target prog.usertext = usertext prog.sequencer_type = sequencer_type prog.temperature = temperature prog.cache_type = cache_type prog.caching_policy = caching_policy session.commit()
def add(session: FileOperator, name: str, prog_name: str, hardware: str, base: str, test: str, is_default: bool, is_enabled: bool): target = { "name": name, "prog_name": prog_name, "hardware": hardware, "base": base, "test": test, "is_default": is_default, "is_enabled": is_enabled, "is_changed": False, "is_changed": False } session.query(Types.Testtarget()).add(target) session.commit()
def add(session: FileOperator, name, hardware, maskset, quality, grade, grade_reference, type, customer, is_enabled): die = { "name": name, "hardware": hardware, "maskset": maskset, "quality": quality, "grade": grade, "grade_reference": grade_reference, "type": type, "customer": customer, "is_enabled": is_enabled } session.query(Types.Die()).add(die) session.commit()
def update(session: FileOperator, name: str, device: str, hardware: str, quality: str, grade: str, grade_reference: str, type: str, customer: str, is_enabled=True): prod = Product.get(session, name) prod.device = device prod.hardware = hardware prod.quality = quality prod.grade = grade prod.grade_reference = grade_reference prod.type = type prod.customer = customer prod.is_enabled = is_enabled session.commit()
def add(session: FileOperator, name: str, hardware: str, base: str, target: str, usertext: str, sequencer_typ: str, temperature: str, owner_name: str, order: int, cache_type: str, caching_policy: str): prog = { "id": str(uuid1()), "prog_name": name, "hardware": hardware, "base": base, "target": target, "usertext": usertext, "sequencer_type": sequencer_typ, "temperature": temperature, "owner_name": owner_name, "prog_order": order, "is_valid": True, "cache_type": cache_type, "caching_policy": caching_policy } session.query(Types.Program()).add(prog) session.commit()
def remove(session: FileOperator, name: str): session.query(Types.Product())\ .filter(lambda Product: Product.name == name)\ .delete() session.commit()
def remove(session: FileOperator, quali_flow_data: DBObject): session.query(Types.Qualification()) \ .filter(lambda QualificationFlowDatum: (QualificationFlowDatum.name == quali_flow_data.name and QualificationFlowDatum.type == quali_flow_data.type and QualificationFlowDatum.product == quali_flow_data.product))\ .delete() session.commit()
def remove(session: FileOperator, name: str): session.query(Types.Package())\ .filter(lambda package: package.name == name)\ .delete() session.commit()
def remove(session: FileOperator, name: str): session.query(Types.Hardware())\ .filter(lambda Hardware: Hardware.name == name)\ .delete() session.commit()
def add(session: FileOperator, name: str, leads: int, is_naked_die: bool, is_enabled: bool): package = {"name": name, "leads": leads, "is_naked_die": is_naked_die, "is_enabled": is_enabled} session.query(Types.Package()).add(package) session.commit()
def update_state(session: FileOperator, name: str, is_enabled: bool): hw = Hardware.get(session, name) hw.is_enabled = is_enabled session.commit()
def update(session: FileOperator, name: str, definition: dict): hw = Hardware.get(session, name) hw.definition = definition session.commit()
def update_state(session: FileOperator, name: str, state: bool): package = session.query(Types.Package())\ .filter(lambda package: package.name == name)\ .one() package.is_enabled = state session.commit()
def update_state(session: FileOperator, name: str, is_enabled: bool): die = Die.get(session, name) die.is_enabled = is_enabled session.commit()
def update_state(session: FileOperator, name: str, state: bool): product = session.query(Types.Product())\ .filter(lambda Product: Product.name == name)\ .one() product.is_enabled = state session.commit()
def remove(session: FileOperator, name: str): session.query(Types.Die())\ .filter(lambda Die: Die.name == name)\ .delete() session.commit()
def add(session: FileOperator, name: str, definition: dict, is_enabled: bool): hw = {"name": name, "definition": definition, "is_enabled": is_enabled} session.query(Types.Hardware()).add(hw) session.commit()