From 7c220dce28725ef61a567e9d5b7ecf1b75344b15 Mon Sep 17 00:00:00 2001 From: mistangl Date: Tue, 19 Dec 2023 15:35:12 +0100 Subject: [PATCH] =?UTF-8?q?Configlibarry=20zum=20Auslesen=20aller=20Werte?= =?UTF-8?q?=20aller=20ben=C3=B6tigten=20Informationen=20aus=20den=20Config?= =?UTF-8?q?=20files=20erstellt?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- cfg/{allgmein.cfg => Allgemein.cfg} | 0 cfg/{Bezeichner.txt => Bezeichner.cfg} | 1 + lib/manage_configs.py | 165 ++++++++++++++++++++++--- lib/test.py | 87 ++++++++++++- 4 files changed, 231 insertions(+), 22 deletions(-) rename cfg/{allgmein.cfg => Allgemein.cfg} (100%) rename cfg/{Bezeichner.txt => Bezeichner.cfg} (99%) diff --git a/cfg/allgmein.cfg b/cfg/Allgemein.cfg similarity index 100% rename from cfg/allgmein.cfg rename to cfg/Allgemein.cfg diff --git a/cfg/Bezeichner.txt b/cfg/Bezeichner.cfg similarity index 99% rename from cfg/Bezeichner.txt rename to cfg/Bezeichner.cfg index 123b55a..e291c21 100644 --- a/cfg/Bezeichner.txt +++ b/cfg/Bezeichner.cfg @@ -1,3 +1,4 @@ +[Bezeichner] 1' Rohr 3/2-Wegeventil 4/2-Wegeventil diff --git a/lib/manage_configs.py b/lib/manage_configs.py index e093b2d..0fd70c1 100644 --- a/lib/manage_configs.py +++ b/lib/manage_configs.py @@ -20,7 +20,6 @@ class JsonBasedConfig: """nimm den Json String zur Initialisierung des Objektes""" return json.loads(json_str) - class TOSGroupsConfig(JsonBasedConfig): """Auslesen der Config Angaben zu den TOS Gruppen""" @@ -71,7 +70,6 @@ class TOSGroupsConfig(JsonBasedConfig): """lade den Json String zur Initialisierung des Objektes""" self.tos_hierarchy = super().from_json(json_str) - class MaterialTransConfig(JsonBasedConfig): """Auslesen der Config zu allen Materialangaben""" @@ -120,32 +118,161 @@ class IniBasedConfig: self.config.read(self.config_path) self.isInitalized = True - def isInitalized(self): - return self.isInitalized - def get_section_options(self, section_name): + if not self.isInitalized: + self.load_cfg_from_file() return self.config.options(section_name) + def sections(self): + if not self.isInitalized: + self.load_cfg_from_file() + return self.config.sections() + + def get_int(self, section_name, option): + if not self.isInitalized: + self.load_cfg_from_file() + return self.config.getint(section_name, option) + + def get_dict(self, section_name): + if not self.isInitalized: + self.load_cfg_from_file() + return dict(self.config.items(section_name)) + +class AllgmeinConfig(IniBasedConfig): + """Auslesen der Config für alle allgemeinen Angaben""" + def __init__(self, config_dir='.', config_file='Allgmein.cfg'): + super().__init__(config_dir, config_file) + + def get_sections(self): + """ gibt alle Sektionen zurück wie + Kategorien, Dispogruppe, Dispolaufgruppe, EinheitAusw, ... + """ + return super().sections() + + def get_options(self, section_name): + """ get all options below""" + return super().get_section_options(section_name) + +class BezeichnerConfig(IniBasedConfig): + """Auslesen der Config zu allen möglichen Bezeichner""" + def __init__(self, config_dir='.', config_file='Bezeichner.cfg'): + super().__init__(config_dir, config_file) + + def get(self): + """hole alle möglichen Bezeichner """ + return super().get_section_options("Bezeichner") + +class FarbenConfig(IniBasedConfig): + """Auslesen der Config zu allen Farbensarten""" + def __init__(self, config_dir='.', config_file='Farbensarten.cfg'): + super().__init__(config_dir, config_file) + + def get_farbauswahl(self): + """hole alle Farben die möglich sind + -> [RAL 1004 Goldgelb, RAL 2000 Gelborange, RAL 3002 Kaminrot, RAL 5010 Enzianblau] + """ + return super().get_section_options("Farbauswahl") + + def get_farben_eloxieren(self): + """hole alle Farben fürs eloxieren + -> [Rot, Grün, Blau, Gelb, Schwarz, Violett, Natur] + """ + return super().get_section_options("FarbeEloxieren") + +class FertigungsartConfig(IniBasedConfig): + """Auslesen der Config zu allen Fertigungsarten""" + def __init__(self, config_dir='.', config_file='Fertigungsarten.cfg'): + super().__init__(config_dir, config_file) + + def get_fertigungsarten(self): + """hole alle Fertigungsarten, welche als Sektionen in der config gegeben sind, also + Fertigungsart, Allgemeintoleranz3DDruck, AllgemeintoleranzGiessen, + AllgemeintoleranzExtrudieren, ... + """ + return super().sections() + + def get_normen_of_type(self, ftype): + """hole alle möglichen Oberflächen Behandlungsarten zum gegebenen Material + Allgemeintoleranz3DDruck ftype + -> [ISO 2768:1991-fH, ISO 2768:1991-fK, ISO 2768:1991-fL, ISO 2768:1991-mH, , ...] + """ + return super().get_section_options(ftype) + +class HerstellerConfig(IniBasedConfig): + """Auslesen der Config zu allen möglichen Hersteller""" + def __init__(self, config_dir='.', config_file='Hersteller.cfg'): + super().__init__(config_dir, config_file) + + def get(self): + """hole alle möglichen Bezeichner """ + return super().get_section_options("Hersteller") + +class NormenConfig(IniBasedConfig): + """Auslesen der Config zu allen Normen""" + def __init__(self, config_dir='.', config_file='Normen.cfg'): + super().__init__(config_dir, config_file) + + def get_normen(self): + """hole alle Normen, welche als Sektionen in der config gegeben sind, also + Oberflaechennorm, Kantennorm, Massnorm, Tolerierungsnorm,.. + """ + return super().sections() + + def get_normen_of_type(self, otype): + """hole alle möglichen Oberflächen Behandlungsarten zum gegebenen Material + Oberfläche otype + Oberflaechennorm -> [ISO 1302:2002, ISO 21920] + Tolerierungsnorm, ... + """ + return super().get_section_options(otype) + +class OberflächeConfig(IniBasedConfig): + """Auslesen der Config zu allen Oberflächen""" + def __init__(self, config_dir='.', config_file='Oberflächenbehandlung.cfg'): + super().__init__(config_dir, config_file) + + def get_oberflächen(self): + """hole alle Oberflächen, welche als Sektionen in der config gegeben + sind, also OberflächenbehandlungStahl, OberflächenbehandlungAluminium, ... """ + return super().sections() + + def get_oberfläche_of_type(self, otype): + """hole alle möglichen Oberflächen Behandlungsarten zum gegebenen Material + Oberfläche otype + OberflächenbehandlungStahl --> [lackieren, pulverbeschichten, verzinken, vernickeln, brünieren, härten, bürsten, sandstrahlen] + OberflächenbehandlungAluminium + ... + """ + return super().get_section_options(otype) + class WerkstoffeConfig(IniBasedConfig): """Auslesen der Config zu allen Werkstoffen""" def __init__(self, config_dir='.', config_file='Werkstoff.cfg'): super().__init__(config_dir, config_file) - def get_werkstoffe_of_type(self, wtype): - """hole alle Werkstoffe unter der gegebenen Sektion - Werkstofftyp wtype - Stahl --> [ 1.0035 (S185), 1.0038 (S235JR), 1.0122 (S235JRC), 1.0122+C (S235JRC+C), 1.0330 (DC01), ... ] - Aluminium - Kunst-/ Verbundstoff - Schwermetall - Festigkeitsklasse - siehe Hersteller - + def get_werkstoff_namen(self): + """hole alle Werkstoffe, welche als Sektionen in der config gegeben sind, also z.B. + Stahl, Aluminium, Kunst-/ Verbundstoff, ... """ - if not super().isInitalized(): - super().load_cfg_from_file() - return super().get_section_options(wtype) + return super().sections() + + def get_werkstoffe_of_name(self, wName): + """hole alle Werkstoffe unter der gegebenen Sektion + Werkstofftyp wName + Stahl --> [ 1.0035 (S185), 1.0038 (S235JR), 1.0122 (S235JRC), 1.0122+C (S235JRC+C), 1.0330 (DC01), ... ] + Aluminium, ... + """ + return super().get_section_options(wName) + +class PfadConfig(IniBasedConfig): + """Auslesen der Config zu allen Pfaden""" + def __init__(self, config_dir='.', config_file='Zielpfade.cfg'): + super().__init__(config_dir, config_file) + + def get(self): + """hole alle möglichen Bezeichner """ + return super().get_section_options("Zielpfade") if __name__ == '__main__': - pass + Kalkulationsart diff --git a/lib/test.py b/lib/test.py index 584beb4..2a1ceb7 100644 --- a/lib/test.py +++ b/lib/test.py @@ -284,7 +284,7 @@ class TestWerkstoffeFromLocalConfigs(unittest.TestCase): WKST_CFG = manage_configs.WerkstoffeConfig(self.config_dir, 'Werkstoff.cfg') - steels = WKST_CFG.get_werkstoffe_of_type("Stahl") + steels = WKST_CFG.get_werkstoffe_of_name("Stahl") result = ['1.0035 (S185)', '1.0038 (S235JR)', '1.0122 (S235JRC)', '1.0122+C (S235JRC+C)', '1.0330 (DC01)', '1.0401 (C15)', '1.0501 (C35)', '1.0503 (C45)', '1.0503+N (C45+N)', @@ -296,7 +296,7 @@ class TestWerkstoffeFromLocalConfigs(unittest.TestCase): 'siehe Hersteller' ] self.assertCountEqual(steels, result) - steels = WKST_CFG.get_werkstoffe_of_type("Aluminium") + steels = WKST_CFG.get_werkstoffe_of_name("Aluminium") result = [ "EN AW-1050A (3.0255)", "EN AW-2007 (3.1645)", "EN AW-2014-T3 (3.1255-T3)", "EN AW-2014-T4 (3.1255-T4)", "EN AW-6060 (3.3206)", "EN AW-6060-T66 (3.3206-T66)", "EN AW-7075 (3.4365)", @@ -360,12 +360,93 @@ siehe Hersteller WKST_CFG = manage_configs.WerkstoffeConfig() WKST_CFG.from_cfg_str(self.wkstoffe) - steels = WKST_CFG.get_werkstoffe_of_type("Stahl") + steels = WKST_CFG.get_werkstoffe_of_name("Stahl") result = ["1.0035 (S185)", "1.0038 (S235JR)", "1.0122 (S235JRC)", "1.0122+C (S235JRC+C)", "1.0330 (DC01)", "1.0401 (C15)", "1.0501 (C35)", "1.0503 (C45)", "1.0503+N (C45+N)", "siehe Hersteller"] self.assertCountEqual(steels, result) +class TestAllgmein(unittest.TestCase): + + def setUp(self): + + self.allgemein = """ + +[Kategorien] +Baugruppe +Einzelteil +Kaufteil +NichtSivas +Normteil +Schweissbaugruppe + +[Dispogruppe] +Fahrstrecke=10 +Förderer=20 +Gerüst=30 +Betriebsmittel=40 +Automation=50 +Kleinteil=60 +Rohmaterial=70 +Sonstiges Intern=80 +Baustelleneinrichtung=90 +Sonderkonstruktionen=100 + +[Dispolaufgruppe] +Omniflo=10 +Intra Logistic System + alt-HFS=20 +Fremd-Transportsysteme + SSG-Anbauten=30 +Spinnereikomponente=40 +Automotiv=45 +Nicht eindeutig, Sonder=50 + +[Kalkulationsart] +Eigenbau +Kaufteil +Mischteil + """ + + def test_get_allgmein(self): + """ + get list of sections in allgmein + """ + + ALLG_CFG = manage_configs.AllgmeinConfig() + ALLG_CFG.from_cfg_str(self.allgemein) + + allg_secs = ALLG_CFG.get_sections() + result = ['Kategorien', 'Dispogruppe', 'Dispolaufgruppe', 'Kalkulationsart'] + self.assertCountEqual(allg_secs, result) + + opts = ALLG_CFG.get_options('Kalkulationsart') + result = ['Eigenbau', 'Kaufteil', 'Mischteil'] + self.assertCountEqual(opts, result) + + opts = ALLG_CFG.get_options('Dispolaufgruppe') + result = ['Omniflo', 'Intra Logistic System + alt-HFS', + 'Fremd-Transportsysteme + SSG-Anbauten', + 'Spinnereikomponente', 'Automotiv', "Nicht eindeutig, Sonder"] + self.assertCountEqual(opts, result) + + val = ALLG_CFG.get_int('Dispolaufgruppe', 'Omniflo') + self.assertEqual(val, 10) + + dint = ALLG_CFG.get_dict('Dispogruppe') + res = { 'Fahrstrecke':10, + 'Förderer':20, + 'Gerüst':30, + 'Betriebsmittel':40, + 'Automation':50, + 'Kleinteil':60, + 'Rohmaterial':70, + 'Sonstiges Intern':80, + 'Baustelleneinrichtung':90, + 'Sonderkonstruktionen':100, + } + self.assertCountEqual(dint, res) + + + if __name__ == '__main__': unittest.main()