import json import math from typing import Counter import unittest from numpy import array #In einem 'Bereich' in der Kalkulationsübersicht werden verwendete Baugruppen nach örtlichen # oder logischen Kriterien der Anlage zusammengefasst #Innerhalb eines Bereichs werden Baugruppen mit Übergabeparametern (Kreisel, Gefällestrecke) und ohne Übergabeparametern (Eckrad, ETF, BT/MT Entladung, # BT Beladung, MT Beladung, Zuführung Klinkenförderer) zusammengefasst. Zusätzlicher Aufschlag für 30° Ausschleuselement/Einschleuselement class Kreisel(): #standardkreisel ohne pin/rampe, bei Bedarf als Parameter übergeben def __init__(self, bezeichnung, anzahl, laenge, anzahl_weichen, anzahl_separatoren, anzahl_scanner, pin=False, anzahl_rampen=0): self.bezeichnung = bezeichnung self.anzahl = anzahl self.laenge = laenge self.pin = pin #bool self.anzahl_rampen = anzahl_rampen self.anzahl_weichen = anzahl_weichen self.anzahl_separatoren = anzahl_separatoren self.anzahl_scanner = anzahl_scanner class Gefaellestrecke(): #standardgefällestrecke ohne 30° EE/AE, bei Bedarf als Parameter übergeben def __init__(self, bezeichnung, anzahl, laenge, anzahl_separatoren, anzahl_scanner, einschleuselement_30_grad=False, ausschleuselement_30_grad=False): self.bezeichnung = bezeichnung self.anzahl = anzahl self.laenge = laenge #TODO: minimum, maximum? self.anzahl_separatoren = anzahl_separatoren self.anzahl_scanner = anzahl_scanner self.einschleuselement_30_grad = einschleuselement_30_grad #bool self.ausschleuselement_30_grad = ausschleuselement_30_grad #bool class Bereich(): def __init__(self,bezeichnung, kreisel:list[Kreisel], gefaellestrecken:list[Gefaellestrecke],anzahl_eckraeder=0, anzahl_etagenfoerderer=0, anzahl_bt_mt_entladung=0, anzahl_bt_beladung=0, anzahl_mt_beladung=0, anzahl_zufuehrung_klinkenf=0, laenge_zufuehrung_klinkenf=0): self._bezeichnung = bezeichnung #für jede instanz der kreiselklasse in der Liste 'kreisel' muss ein Materialpreis und Montagestunden berechnet werden #Äquivalent dazu Gefällestrecken, ETF, So-Förderer und Umbügeln berechnen #Summe aller Baugruppen eines Kreisel # Materialpreis mech+el=D3*( Tabellen!C3 + E3*Tabellen!D3 + F3*E3*Tabellen!E3 + G3*Tabellen!F3 + H3*Tabellen!H3 + I3*Tabellen!I3 + J3*Tabellen!R3 + F3*Tabellen!G3) # Anzahl_Kreisel*((PreisAntr+Spannstation) + Länge*PreismKreisel + Pin*Länge*Aufpr.Pin + Rampen*PreisRampe + Weichen*PreisWeiche + Separatoren*PreisSepLP + Scanner*PreisScanSep + Pin*PreisInkGeber) # Anzahl_Kreisel*((=BaaN!G3+BaaN!G5) + Länge*(=BaaN!G8) + Pin*Länge*(=BaaN!G10) + Rampen*(=BaaN!G11) + Weichen*(=BaaN!G12) + Separatoren*(=BaaN!G14) + Scanner*(=BaaN!G16) + Pin*(=BaaN!E29)) # Montagestunden # =D3*( Tabellen!C30 + E3*Tabellen!D30 + F3*E3*Tabellen!E30 + G3*Tabellen!F30 + H3*Tabellen!H30 + I3*Tabellen!I30 + J3*Tabellen!R30 + F3*Tabellen!G30) self.bauteile = { "Antriebsstation": 0, "Spannstation": 0, "Rampe": 0, "Weiche": 0, "Separator_LP": 0, "Separator_SP": 0, "Ausschleuselement": 0, "BTMT_Entladung": 0, "BT_Beladung": 0, "MT_Beladung": 0, "Etagenfoerderer": 0, "Sonst_Foerderer": 0, "Inkrementalgeber": 0, "Scanner": 0, } self.bauteile["Antriebsstation"] += anzahl_eckraeder # BaaN => Montagezeit und Herstellkosten einzelner Baugruppen b = BaaN() self._kreisel = {} kreisel_hk_mech_el_summe = 0 kreisel_mont_mech_el_summe = 0 for k in kreisel: self.bauteile["Antriebsstation"] += k.anzahl self.bauteile["Spannstation"] += k.anzahl self.bauteile["Rampe"] += k.anzahl_rampen self.bauteile["Weiche"] += k.anzahl_weichen self.bauteile["Separator_LP"] += k.anzahl_separatoren self.bauteile["Scanner"] += k.anzahl_scanner pin = 0 if(k.pin == True): pin = 1 kreisel_hk_mech_el = k.anzahl * (b.herstellkosten_mech_el("ANTRIEBSSTATION_800_ILS_20_(mit_Motor)") + b.herstellkosten_mech_el("SPANNSTATION_800_ILS_20") +\ k.laenge * b.herstellkosten_mech_el("1_Meter_Kreisel_LP_20") + pin*k.laenge*b.herstellkosten_mech_el("Zusatzaufwand_für_Meter_Pinband") +\ k.anzahl_rampen * b.herstellkosten_mech_el("Rampe_li_u_re_incl_LPhc_u_Zappler") + k.anzahl_weichen * b.herstellkosten_mech_el("Weiche_ILS_20") +\ k.anzahl_separatoren * b.herstellkosten_mech_el("Sep_LP_ILS_20_(SMC)") + k.anzahl_scanner * b.herstellkosten_mech_el("SCANNER_FÜR_SEPARATOR") +\ pin * b.herstellkosten_mech_el("Inkrementalgeber")) kreisel_mont_mech_el = k.anzahl * (b.montagestunden_mech_el("ANTRIEBSSTATION_800_ILS_20_(mit_Motor)") + b.montagestunden_mech_el("SPANNSTATION_800_ILS_20") +\ k.laenge * b.montagestunden_mech_el("1_Meter_Kreisel_LP_20") + pin*k.laenge*b.montagestunden_mech_el("Zusatzaufwand_für_Meter_Pinband") +\ k.anzahl_rampen * b.montagestunden_mech_el("Rampe_li_u_re_incl_LPhc_u_Zappler") + k.anzahl_weichen * b.montagestunden_mech_el("Weiche_ILS_20") +\ k.anzahl_separatoren * b.montagestunden_mech_el("Sep_LP_ILS_20_(SMC)") + k.anzahl_scanner * b.montagestunden_mech_el("SCANNER_FÜR_SEPARATOR") +\ pin * b.montagestunden_mech_el("Inkrementalgeber")) kreisel_hk_mech_el_summe += kreisel_hk_mech_el kreisel_mont_mech_el_summe += kreisel_mont_mech_el self._kreisel[k.bezeichnung] ={"hk_summe": round(kreisel_hk_mech_el,2), "mont_summe": round(kreisel_mont_mech_el/60, 2)} self._kreisel["_GESAMT_"] = {"hk_summe": round(kreisel_hk_mech_el_summe,2), "mont_summe": round(kreisel_mont_mech_el_summe/60,2)} #TODO: Eckrad Montagestundenberechnung => *1.5? self._eckraeder = {"hk_summe": round(anzahl_eckraeder*(b.herstellkosten_mech_el("ANTRIEBSSTATION_800_ILS_20_(mit_Motor)")),2), "mont_summe": round((anzahl_eckraeder*b.montagestunden_mech_el("ANTRIEBSSTATION_800_ILS_20_(mit_Motor)")*1.5)/60,2)} # =D17*(Tabellen!J3+E17*Tabellen!L3+I17*Tabellen!M3+J17*Tabellen!R3) # = Anzahl * (AE+EE + Länge * mSP + Separatoren * Sep + Scanner * ScanSep) # = =BaaN!G19+BaaN!G20 =BaaN!G13 =BaaN!G15 =BaaN!G16 # Aufschlag AE/EE 30°: =BaaN!C24-BaaN!C19 gefaelle_hk_mech_el_summe = 0 gefaelle_mont_mech_el_summe = 0 self._gefaellestrecken = {} for g in gefaellestrecken: self.bauteile["Separator_SP"] += g.anzahl_separatoren #TODO: Ausschleuselement 30° wird hier nicht addiert? if(g.ausschleuselement_30_grad == False): self.bauteile["Ausschleuselement"] += g.anzahl hkAE = b.herstellkosten_mech_el("AE_ILS_20_(SMC)") montAE = b.montagestunden_mech_el("AE_ILS_20_(SMC)") hkEE = b.herstellkosten_mech_el("EE") montEE = b.montagestunden_mech_el("EE") #TODO: Zusatzaufwand für 30° EE/AE bezieht sich ausschließlich auf Differenz zwischen Material mechanik(HK) zwischen AE und AE30° #TODO: Montagezeit korrekt, allerdings wird für die Berechnung von Einschleuselementen ebenfalls Zahlen der AS verwendet #TODO: keine Montagezeiten elektrik für AE/EE 30°! # Hier: Berechnung entweder auf Grundlage von standard AE/EE oder mit 30° aus Klasse Baan() if(g.ausschleuselement_30_grad): hkAE = b.herstellkosten_mech_el("AS_ELEMENT_30_MIT_SMC_PNEUMATIK_F_SF_ILS") montAE = b.montagestunden_mech_el("AS_ELEMENT_30_MIT_SMC_PNEUMATIK_F_SF_ILS") if(g.einschleuselement_30_grad): hkEE = b.herstellkosten_mech_el("ES_ELEMENT_30_F_SF_ILS") montEE = b.montagestunden_mech_el("ES_ELEMENT_30_F_SF_ILS") gefaelle_hk_mech_el = g.anzahl * (hkAE + hkEE + g.laenge * b.herstellkosten_mech_el("SP_ILS_20") +\ g.anzahl_separatoren * b.herstellkosten_mech_el("Sep_SP_HD_ILS_20_(SMC)") + g.anzahl_scanner * b.herstellkosten_mech_el("SCANNER_FÜR_SEPARATOR")) gefaelle_mont_mech_el = g.anzahl * (montAE + montEE + g.laenge * b.montagestunden_mech_el("SP_ILS_20") +\ g.anzahl_separatoren * b.montagestunden_mech_el("Sep_SP_HD_ILS_20_(SMC)") + g.anzahl_scanner * b.montagestunden_mech_el("SCANNER_FÜR_SEPARATOR")) gefaelle_hk_mech_el_summe += gefaelle_hk_mech_el gefaelle_mont_mech_el_summe += gefaelle_mont_mech_el self._gefaellestrecken[g.bezeichnung] = {"hk_summe": round(gefaelle_hk_mech_el,2), "mont_summe": round(gefaelle_mont_mech_el/60, 2)} self._gefaellestrecken["_GESAMT_"] = {"hk_summe": round(gefaelle_hk_mech_el_summe,2), "mont_summe": round(gefaelle_mont_mech_el_summe/60,2)} #Etagenförderer etf_hk_mech_el = anzahl_etagenfoerderer * b.herstellkosten_mech_el("ETF_6m_Zw_Träger_ILS_20") etf_mont_mech_el = anzahl_etagenfoerderer * b.montagestunden_mech_el("ETF_6m_Zw_Träger_ILS_20") self._etagenfoerderer = {"hk_summe": round(etf_hk_mech_el,2), "mont_summe": round(etf_mont_mech_el/60,2)} #TODO: so-förderer #Umbügeln self._btmt_entladung = {"hk_summe": round(anzahl_bt_mt_entladung * b.herstellkosten_mech_el("BT_MT_Entladg"),2), "mont_summe": round((anzahl_bt_mt_entladung*b.montagestunden_mech_el("BT_MT_Entladg"))/60,2)} self._bt_beladung = {"hk_summe": round(anzahl_bt_beladung * b.herstellkosten_mech_el("BT_Beladg"),2), "mont_summe": round((anzahl_bt_beladung * b.montagestunden_mech_el("BT_Beladg"))/60,2)} self._mt_beladung = {"hk_summe": round(anzahl_mt_beladung * b.herstellkosten_mech_el("MT_Beladg"),2), "mont_summe": round((anzahl_mt_beladung * b.montagestunden_mech_el("MT_Beladg"))/60,2)} #zuführung klinkenförderer=D37*Tabellen!E62+D37*E37*Tabellen!F62 TODO: Keine Artikel hinterlegt, ausschließlich Zahlenwerte -> Überprüfen # Klinkenförderer: Antrieb = 920, E-Material = 200, proMeter = 160, MontageAntrieb = 3(h), MontageMeter = 1(h) self._zufuehrung_cpc = {"hk_summe": round(anzahl_zufuehrung_klinkenf * (920 + laenge_zufuehrung_klinkenf),2), "mont_summe": round((anzahl_zufuehrung_klinkenf * (3 + laenge_zufuehrung_klinkenf * 1))/60,2)} def getBauteile(self): return self.bauteile def getResult(self): res = { "Kreisel": self._kreisel, "Eckraeder": self._eckraeder, "Gefaellestrecken": self._gefaellestrecken, "Etagenfoerderer": self._etagenfoerderer, "BTMT_Entladung": self._btmt_entladung, "BT_Beladung": self._bt_beladung, "MT_Beladung": self._mt_beladung, "Zufuehrung_Klinke": self._zufuehrung_cpc, } return res def getSummenBereich(self): hk_sum = 0 mont_sum = 0 hk_sum += self._kreisel.get("_GESAMT_", {}).get("hk_summe", 0) hk_sum += self._gefaellestrecken.get("_GESAMT_", {}).get("hk_summe", 0) hk_sum += self._eckraeder.get("hk_summe", 0) hk_sum += self._etagenfoerderer.get("hk_summe", 0) #TODO: So Förderer hk_sum += self._btmt_entladung.get("hk_summe", 0) hk_sum += self._bt_beladung.get("hk_summe", 0) hk_sum += self._mt_beladung.get("hk_summe", 0) hk_sum += self._zufuehrung_cpc.get("hk_summe", 0) mont_sum += self._kreisel.get("_GESAMT_", {}).get("mont_summe", 0) mont_sum += self._gefaellestrecken.get("_GESAMT_", {}).get("mont_summe", 0) mont_sum += self._eckraeder.get("mont_summe", 0) mont_sum += self._etagenfoerderer.get("mont_summe", 0) #TODO: So Förderer mont_sum += self._btmt_entladung.get("mont_summe", 0) mont_sum += self._bt_beladung.get("mont_summe", 0) mont_sum += self._mt_beladung.get("mont_summe", 0) mont_sum += self._zufuehrung_cpc.get("mont_summe", 0) return {"Materialkosten": round(hk_sum, 2), "Montagezeit": round(mont_sum, 2)} #Ohne Aufschläge, reine HK Kosten bzw Montagezeiten def tojson(self, input:dict): return json.dumps(input, sort_keys=False, indent=4) def resToFile(self): json = self.tojson(self.getResult()) fname = "Bereich_" + self._bezeichnung + ".json" with open("Bereichszusammenfassung.json", "w") as file: file.write(json) class Taschen(): def __init__(self, baugruppensummen:type[dict]): #Zusatzbauteile die für Taschentransport erforderlich sind self._Zusatzbauteile = { #"Bezeichnung":[Einzelpreis, Montagedauer(h)], Teilenummer "Fuehrung_an_AE": [22.0, 0.1], #829514073 "Halter_Gegenleiste_an_AE": [0.6, 0.02], #829514071 "Aluwinkel_40x20": [2.6, 0.02], #931011103 "Halter_Gegenleiste_an_EE": [2.6, 0.02], #829514070 "Alu_4kt_20x20": [4.7, 0.1], #931601003 "Rollenandruckleiste_Sep_LP": [45.0, 0.05], #829534007 "Abhebeleiste_Sep_LP": [89.0, 0.5], #829534008 "Zwangsfuehrung_Sep_SP": [34.0, 0.1], #829514072 #Schrägkreisel und Noppenband wird nicht übernommen, da nicht mehr verwendet } self._Summen = { #"Bezeichnung":[Summe Preis, Summe Montagedauer] "Fuehrung_an_AE": [0, 0], #829514073 "Halter_Gegenleiste_an_AE": [0, 0], #829514071 "Aluwinkel_40x20": [0, 0], #931011103 "Halter_Gegenleiste_an_EE": [0, 0], #829514070 "Alu_4kt_20x20": [0, 0], #931601003 "Rollenandruckleiste_Sep_LP": [0, 0], #829534007 "Abhebeleiste_Sep_LP": [0, 0], #829534008 "Zwangsfuehrung_Sep_SP": [0, 0], #829514072 } #Gesamtanzahl von AE, Sep_LP, Sep_SP und Scanner auslesen summe_ausschleuselement = baugruppensummen.get("Ausschleuselement", 0) summe_sepLP_scanner = baugruppensummen.get("Separator_LP", 0) + baugruppensummen.get("Scanner", 0) summe_sepSP = baugruppensummen.get("Separator_SP", 0) self._Summen["Fuehrung_an_AE"] = [round(self._Zusatzbauteile.get("Fuehrung_an_AE", [])[0] * summe_ausschleuselement,2), round(self._Zusatzbauteile.get("Fuehrung_an_AE", [])[1] * summe_ausschleuselement,2)] self._Summen["Halter_Gegenleiste_an_AE"] = [round(self._Zusatzbauteile.get("Halter_Gegenleiste_an_AE", [])[0] * summe_ausschleuselement,2), round(self._Zusatzbauteile.get("Halter_Gegenleiste_an_AE", [])[1] * summe_ausschleuselement,2)] self._Summen["Aluwinkel_40x20"] = [round(self._Zusatzbauteile.get("Aluwinkel_40x20", [])[0] * summe_ausschleuselement,2), round(self._Zusatzbauteile.get("Aluwinkel_40x20", [])[1] * summe_ausschleuselement,2)] self._Summen["Halter_Gegenleiste_an_EE"] = [round(self._Zusatzbauteile.get("Halter_Gegenleiste_an_EE", [])[0] * summe_ausschleuselement,2), round(self._Zusatzbauteile.get("Halter_Gegenleiste_an_EE", [])[1] * summe_ausschleuselement,2)] self._Summen["Alu_4kt_20x20"] = [round(self._Zusatzbauteile.get("Alu_4kt_20x20", [])[0] * summe_ausschleuselement, 2), round(self._Zusatzbauteile.get("Alu_4kt_20x20", [])[1] * summe_ausschleuselement, 2)] self._Summen["Rollenandruckleiste_Sep_LP"] = [round(self._Zusatzbauteile.get("Rollenandruckleiste_Sep_LP", [])[0] * summe_sepLP_scanner * 0.2,2), #TODO: warum mit 0.2 multipliziert? round(self._Zusatzbauteile.get("Rollenandruckleiste_Sep_LP", [])[1] * summe_sepLP_scanner * 0.2,2)] self._Summen["Abhebeleiste_Sep_LP"] = [round(self._Zusatzbauteile.get("Abhebeleiste_Sep_LP", [])[0] * summe_sepLP_scanner * 0.2,2), round(self._Zusatzbauteile.get("Abhebeleiste_Sep_LP", [])[1] * summe_sepLP_scanner * 0.2,2)] self._Summen["Zwangsfuehrung_Sep_SP"] = [round(self._Zusatzbauteile.get("Zwangsfuehrung_Sep_SP", [])[0] * summe_sepSP * 0.5, 2), round(self._Zusatzbauteile.get("Zwangsfuehrung_Sep_SP", [])[1] * summe_sepSP * 0.5, 2)] print(self._Summen) class Deckblatt(): def __init__(self, bereiche:type[list[Bereich]], taschentransport=False): #zusatzbauteile/Aufwand wenn Taschen im System laufen if(taschentransport): i=0 #Summe aller Baugruppen über alle Bereiche self._Baugruppensummen = {} for b in bereiche: t = b.getBauteile() t_count = Counter(t) bgr_summen_count = Counter(self._Baugruppensummen) sum_dict = t_count + bgr_summen_count self._Baugruppensummen = dict(sum_dict) class BaaN(): def __init__(self): self._Kosten = { #[HK mechanik, Montage mechanik(min), HK elektrik, Montage elektrik(min)] "ANTRIEBSSTATION_800_ILS_20_(mit_Motor)":[1580,360,233,240], "SPANNSTATION_800_ILS_20":[1110,360,24,120], "1_Meter_Kreisel_LP_20":[75,90,0,0], "Zusatzaufwand_für_Meter_Pinband":[3,30,0,0], "Rampe_li_u_re_incl_LPhc_u_Zappler":[202,60,76.3,45], "Weiche_ILS_20":[225,60,52.2,30], "SP_ILS_20":[22,20,0,0], "Sep_LP_ILS_20_(SMC)":[206,45,109,60], "Sep_SP_HD_ILS_20_(SMC)":[217,45,53.1,30], "SCANNER_FÜR_SEPARATOR":[0,0,740,60], "HANDSCANNER_FÜR_WARE":[0,0,1860,60], "SCANNER_FÜR_WARE_AUTOMATISCH":[0,0,7470,120], "AE_ILS_20_(SMC)":[152,45,47.5,30], "EE":[68,30,0,0], "BT_MT_Entladg":[450,180,65,120], "BT_Beladg":[1075,240,1125,120], "MT_Beladg":[1300,240,277,120], "AS_ELEMENT_30_MIT_SMC_PNEUMATIK_F_SF_ILS":[300,180,55.7,0], "ES_ELEMENT_30_F_SF_ILS":[240,180,45.7,0], "ETF_6m_Zw_Träger_ILS_20":[2750,720,69,120], "Inkrementalgeber":[0,0,430,180], } self._Taschen = { #zusatzaufwand, wenn Taschen im System laufen # [Preis, Montagezeit] "829514073_Führg_an_AE": [22.0,1], "829514071_Halter_Gegenl_an_AE": [0.6, 0.02], "931011103_Alu_Winkel_40x20": [2.6, 0.02], "829514070_Halter_Gegenl_an_EE": [2.6, 0.02], "931601003_Alu_4_kt_20x20": [4.7, 0.1], "829534007_Andr_Rollenl_Sep_LP": [45, 0.05], "829534008_Abh_Leiste_vor_Sep_LP": [89, 0.5], "829514072_Zwangsführg_an_Sep_SP": [34, 0.1], "829514068_Verb_Schrägkr_Mitte": [6.8, 0.02], "829514069_Verb_Schrägkr_Ende": [11.4, 0.02], "829514061_Rampe": [57, 0.1], "829416031_Stauprofil": [14.5, 0.05], "LP_oben_abschneiden": [1, 0], #Arbeitsgang #"829514075_Abstands_Band_Nop": [2.15, 0.01], #nicht mehr verwendet #"Aufpreis_Band_noppen": [0.6, 0] #nicht mehr verwendet } def herstellkosten_mech(self, artikelbezeichnung): l = self._Kosten.get(artikelbezeichnung, [0,0,0,0]) return l[0] def montagestunden_mech(self, artikelbezeichnung): l = self._Kosten.get(artikelbezeichnung, [0,0,0,0]) return l[1] def herstellkosten_el(self, artikelbezeichnung): l = self._Kosten.get(artikelbezeichnung, [0,0,0,0]) return l[2] def montagestunden_el(self, artikelbezeichnung): l = self._Kosten.get(artikelbezeichnung, [0,0,0,0]) return l[3] def herstellkosten_mech_el(self, artikelbezeichnung): l = self._Kosten.get(artikelbezeichnung, [0,0,0,0]) return l[0] + l[2] def montagestunden_mech_el(self, artikelbezeichnung): l = self._Kosten.get(artikelbezeichnung, [0,0,0,0]) return l[1] + l[3] class TestObjects(unittest.TestCase): def test(self): baan = BaaN() self.assertEqual(baan.herstellkosten_mech("ES_ELEMENT_30_F_SF_ILS"), 240) self.assertEqual(baan.montagestunden_mech("ES_ELEMENT_30_F_SF_ILS"), 180) self.assertEqual(baan.herstellkosten_el("ES_ELEMENT_30_F_SF_ILS"), 45.7) self.assertEqual(baan.montagestunden_el("ES_ELEMENT_30_F_SF_ILS"), 0) kreisel = [] kreisel.append(Kreisel("Zufuehrung Richtung Puffer",2, 30, 4,4,4)) kreisel.append(Kreisel("Verbindung",3,4,0,0,0)) kreisel.append(Kreisel("Einschleusung Puffer",6, 10, 0,2,1,True,2)) kreisel.append(Kreisel("Abzug Puffer",6,10,1,2,2)) kreisel.append(Kreisel("Abzug Gesamt",2,33.5,5,3,0)) gefaellestrecken = [] gefaellestrecken.append(Gefaellestrecke("Umschleusung",6, 10,2,0)) gefaellestrecken.append(Gefaellestrecke("Puffer", 72, 21,2,0)) puffer = Bereich("Puffer",kreisel, gefaellestrecken,12, 6) puffer.resToFile() dblatt = Deckblatt([puffer, puffer]) taschen = Taschen(dblatt._Baugruppensummen) if __name__ == '__main__': unittest.main()