def import_opus( ad_reader=None, import_all: bool = False, import_last=False, opus_id=None, rundb_write: bool = True, ) -> None: """Import one or all files from opus even if no previous files have been imported""" settings = load_settings() filter_ids = settings.get("integrations.opus.units.filter_ids", []) skip_employees = settings.get("integrations.opus.skip_employees", False) dumps = opus_helpers.read_available_dumps() all_dates = dumps.keys() # Default is read first file only export_dates = [min(all_dates)] if import_last: export_dates = [max(all_dates)] elif import_all: export_dates = sorted(all_dates) export_dates = prepend(None, export_dates) date_pairs = pairwise(export_dates) for date1, date2 in date_pairs: import_one( ad_reader, date2, date1, dumps, filter_ids, opus_id=opus_id, rundb_write=rundb_write, )
def list_org_units(session, org_name: str) -> list: query = session.query(Enhed.bvn, Enhed.organisatorisk_sti) data = query.all() data_df = pd.DataFrame(data, columns=["Enhedsnr", "Sti"]) data_df = expand_org_path(data_df, "Sti") # Return data as a list of tuples with columns as the first element parsed_data = list(prepend(data_df.columns, data_df.to_records(index=False))) return parsed_data
def _print_res_row(cls, row_key: str, res_row: Iterable[object]) -> None: """Print the given simulation row. `cls` is the writer class. `row_key` is the row key. `res_row` is the simulation row. """ cls._writer.writerow(prepend(row_key, res_row))
def _fill_cp_util(processor: ProcessorDesc, program: Sequence[HwInstruction], util_info: BagValDict[ICaseString, InstrState], issue_rec: _IssueInfo) -> None: """Calculate the utilization of a new clock pulse. `processor` is the processor to fill the utilization of whose units at the current clock pulse. `program` is the program to execute. `util_info` is the unit utilization information to fill. `issue_rec` is the issue record. """ in_units = chain(processor.in_out_ports, processor.in_ports) dst_units = more_itertools.prepend( _instr_sinks.OutSink(_get_out_ports(processor)), map(lambda dst: _instr_sinks.UnitSink(dst, program), chain(processor.out_ports, processor.internal_units))) _fill_inputs(_build_cap_map(processor_utils.units.sorted_models(in_units)), program, util_info, _mov_flights(dst_units, util_info), issue_rec)
def test_stalled_outputs_are_not_flushed(self, extra_instr_lst): """Test data hazards at output ports. `self` is this test case. `extra_instr_lst` is the extra instructions to execute after the ones causing the hazard. """ program = starmap(HwInstruction, chain( [[[], "R1", "ALU"], [["R1"], "R2", "ALU"]], extra_instr_lst)) extra_instr_len = len(extra_instr_lst) cores = starmap(lambda name, width: UnitModel( ICaseString(name), width, ["ALU"], LockInfo(True, True), []), [("core 1", 1), ("core 2", 1 + extra_instr_len)]) extra_instr_seq = range(2, 2 + extra_instr_len) assert simulate( tuple(program), HwSpec(ProcessorDesc([], [], cores, []))) == [ BagValDict(cp_util) for cp_util in [{ICaseString("core 1"): [InstrState(0)], ICaseString( "core 2"): starmap(InstrState, more_itertools.prepend( [1, StallState.DATA], ([instr] for instr in extra_instr_seq)))}, {ICaseString("core 2"): [InstrState(1)]}]]
def test_hazard(self, in_width, in_mem_util, out_unit_params, extra_util): """Test detecting structural hazards. `self` is this test case. `in_width` is the width of the input unit. `in_mem_util` is the list of input unit capabilities requiring memory utilization. `out_unit_params` are the creation parameters of output units. `extra_util` is the extra utilization beyond the second clock pulse. """ in_unit = UnitModel(ICaseString("input"), in_width, ["ALU"], LockInfo(True, False), in_mem_util) out_units = (UnitModel(ICaseString(name), width, ["ALU"], LockInfo(False, True), mem_access) for name, width, mem_access in out_unit_params) out_units = (FuncUnit(out_unit, [in_unit]) for out_unit in out_units) cp1_util = {ICaseString("input"): map(InstrState, range(in_width))} assert simulate( [HwInstruction([], out_reg, "ALU") for out_reg in ["R1", "R2"]], HwSpec(ProcessorDesc([in_unit], out_units, [], []))) == list( map(BagValDict, more_itertools.prepend(cp1_util, extra_util)))
def test_multiple(self): value = 'ab' iterator = iter('cdefg') actual = tuple(mi.prepend(value, iterator)) expected = ('ab', ) + tuple('cdefg') self.assertEqual(actual, expected)
def test_basic(self): value = 'a' iterator = iter('bcdefg') actual = list(mi.prepend(value, iterator)) expected = list('abcdefg') self.assertEqual(actual, expected)
def list_MED_members(session, org_names: dict) -> list: """Lists all "tilknyntninger" to an organisation. Returns a list of tuples with titles as first element and data on members in subsequent tuples. Example: [ ("Navn", "Email", "Tilknytningstype", "Enhed"), ("Fornavn Efternavn", "*****@*****.**", "Formand", "Enhed") ] """ alle_enheder = set_of_org_units(session, org_names["løn"]) alle_MED_enheder = set_of_org_units(session, org_names["MED"]) Emails = ( session.query(Adresse.værdi, Adresse.bruger_uuid) .filter( Adresse.adressetype_titel == "AD-Email", or_( Adresse.synlighed_titel.is_(None), Adresse.synlighed_titel != "Hemmelig", ), ) .subquery() ) Phonenr = ( session.query(Adresse.værdi, Adresse.bruger_uuid) .filter( Adresse.adressetype_titel == "AD-Telefonnummer", or_( Adresse.synlighed_titel.is_(None), Adresse.synlighed_titel != "Hemmelig", ), ) .subquery() ) eng_unit = ( session.query( Enhed.navn, Enhed.organisatorisk_sti, Engagement.bruger_uuid ).filter( Enhed.uuid == Engagement.enhed_uuid, Engagement.enhed_uuid.in_(alle_enheder), Engagement.bruger_uuid == Bruger.uuid, ) ).subquery() query = ( session.query( Bruger.fornavn + " " + Bruger.efternavn, Emails.c.værdi, Phonenr.c.værdi, Tilknytning.tilknytningstype_titel, Enhed.navn, eng_unit.c.navn, eng_unit.c.organisatorisk_sti, ) .filter( Enhed.uuid == Tilknytning.enhed_uuid, Tilknytning.enhed_uuid.in_(alle_MED_enheder), Tilknytning.bruger_uuid == Bruger.uuid, ) .join(Emails, Emails.c.bruger_uuid == Bruger.uuid, isouter=True) .join(Phonenr, Phonenr.c.bruger_uuid == Bruger.uuid, isouter=True) .join(eng_unit, eng_unit.c.bruger_uuid == Bruger.uuid) .order_by(Bruger.efternavn) ) data = query.all() data_df = pd.DataFrame( data, columns=[ "Navn", "Email", "Telefonnummer", "Tilknytningstype", "Tilknytningsenhed", "Ansættelsesenhed", "Sti", ], ) data_df = expand_org_path(data_df, "Sti") # Return data as a list of tuples with columns as the first element parsed_data = list(prepend(data_df.columns, data_df.to_records(index=False))) return parsed_data
def list_employees(session, org_name: str) -> list: """Lists all employees in organisation. Returns a list of tuples with titles as first element and data on employees in subsequent tuples. Example: [ (Navn", "CPR", "Email", "Telefon", "Enhed", "Stilling"), ("Fornavn Efternavn", 0123456789, "*****@*****.**", "12345678", "Enhedsnavn", "Stillingsbetegnelse") ] """ alle_enheder = set_of_org_units(session, org_name) Emails = ( session.query(Adresse.værdi, Adresse.bruger_uuid) .filter( Adresse.adressetype_titel == "AD-Email", or_( Adresse.synlighed_titel.is_(None), Adresse.synlighed_titel != "Hemmelig", ), ) .subquery() ) Phonenr = ( session.query(Adresse.værdi, Adresse.bruger_uuid) .filter( Adresse.adressetype_titel == "AD-Telefonnummer", or_( Adresse.synlighed_titel.is_(None), Adresse.synlighed_titel != "Hemmelig", ), ) .subquery() ) query = ( session.query( Bruger.fornavn + " " + Bruger.efternavn, Bruger.cpr, Emails.c.værdi, Phonenr.c.værdi, Enhed.navn, Enhed.organisatorisk_sti, Engagement.stillingsbetegnelse_titel, ) .filter( Enhed.uuid == Engagement.enhed_uuid, Engagement.enhed_uuid.in_(alle_enheder), Engagement.bruger_uuid == Bruger.uuid, ) .join(Emails, Emails.c.bruger_uuid == Bruger.uuid, isouter=True) .join(Phonenr, Phonenr.c.bruger_uuid == Bruger.uuid, isouter=True) .order_by(Bruger.efternavn) ) data = query.all() data_df = pd.DataFrame( data, columns=[ "Navn", "CPR", "AD-Email", "AD-Telefonnummer", "Enhed", "Sti", "Stilling", ], ) data_df = expand_org_path(data_df, "Sti") # Return data as a list of tuples with columns as the first element parsed_data = list(prepend(data_df.columns, data_df.to_records(index=False))) return parsed_data
def test_multiple(self): value = 'ab' iterator = iter('cdefg') actual = tuple(mi.prepend(value, iterator)) expected = ('ab',) + tuple('cdefg') self.assertEqual(actual, expected)
def __iter__(self) -> Iterator[Card]: return (mitt.prepend(self.set_aside, super().__iter__()) if self.set_aside is not None else super().__iter__())
def test_multiple(self): value = "ab" iterator = iter("cdefg") actual = tuple(mi.prepend(value, iterator)) expected = ("ab",) + tuple("cdefg") self.assertEqual(actual, expected)
def test_basic(self): value = "a" iterator = iter("bcdefg") actual = list(mi.prepend(value, iterator)) expected = list("abcdefg") self.assertEqual(actual, expected)