View difference between Paste ID: Qkhvybi7 and q08hh2kx

 import re
 class AccountTree():
     def __init__(self):
         self.struct = {}  # На Всяко дете, кой е прекия родител
         self.children = None
         self.top_digits = {}  # На коя сметка колко цифри има в първата група
         self.groups = {}  # На коя сметка колко групи има
         self.top_group_min_digits_count = None     # Беше None
         self.top_group_max_digits_count = None     # Беше None
-        self.top_group_min_digits_count = None  # Беше None
+        self.max_groups_count = None               # Беше None
-        self.top_group_max_digits_count = None  # Беше None
+
-        self.max_groups_count = None  # Беше None
+
-        self.max_depth = None
+    def add_code(self, code):   # TODO IZPOLZWAM 1 Прави STRUCT !!!
-        self.all_accs = []
+
         # "123-456-789" дава ["123", "456", "789"]
         groups_digits = re.findall('[0-9]+', code)
-    def add_code(self, code):  # TODO IZPOLZWAM 1 Прави STRUCT !!!
+
         groups_seps = re.findall('[^0-9]+', code)
         groups_digits_len = len(groups_digits)
 
         # Следим максималния брой аналитични сметки
         if self.max_groups_count is None:
             self.max_groups_count = groups_digits_len
         elif groups_digits_len > self.max_groups_count: # МОже би трябва да е IF ???
             self.max_groups_count = groups_digits_len
 
-        elif groups_digits_len > self.max_groups_count:  # МОже би трябва да е IF ???
+
         #1
         #12     -------TODO----- ВАЖНО -> ТОП родителя е този, който е подаден от Excel с най-малко цифри !!!
-        # 1
+        #123    -------TODO---- -> Няма смисъл да раздробяваме на по-малки кодове сметките в Оборотната ведомост !
-        # 12     -------TODO----- ВАЖНО -> ТОП родителя е този, който е подаден от Excel с най-малко цифри !!!
+        #123-456
-        # 123    -------TODO---- -> Няма смисъл да раздробяваме на по-малки кодове сметките в Оборотната ведомост !
+        #123-456-789
-        # 123-456
+
-        # 123-456-789
+
         top_group_digits = groups_digits[0]  # Първата група
         #print("top_group_digits", top_group_digits)
-        # print("top_group_digits", top_group_digits)
+
 
         # В ancestors ще трупаме [сметка, родител, пра-родител и т.н.] но по цели групи от цифри
         ancestors = []
         ancestors_top_group_digits = []
         ancestors_groups = []
         # За ["123", "456", "789"] len1 ще мине през 3, 2, 1
         for len1 in range(groups_digits_len, 0, -1):
             # len1=3 дава ["123", "456", "789"]
             # len1=2 дава ["123", "456"]
             # len1=1 дава ["123"]
             code1 = ""
             # len1=3, то idx ше мине през 0, 1, 2
             # len1=2, то idx ше мине през 0, 1
             # len1=1, то idx ше мине през 0
             for idx in range(len1):
                 if code1 != "":
                     code1 += groups_seps[idx - 1]
                     pass
                 code1 += groups_digits[idx]
             ancestors.append(code1)
             ancestors_top_group_digits.append(top_group_digits_len)
             ancestors_groups.append(len1)
 
         # Следим коя е най-дългата първа група
         if self.top_group_max_digits_count is None:
             self.top_group_max_digits_count = top_group_digits_len
         elif top_group_digits_len > self.top_group_max_digits_count:
             self.top_group_max_digits_count = top_group_digits_len
         # Следим коя е най-късата първа група
         if self.top_group_min_digits_count is None:
             self.top_group_min_digits_count = top_group_digits_len
         elif top_group_digits_len < self.top_group_min_digits_count:
             self.top_group_min_digits_count = top_group_digits_len
-        for len1 in range(top_group_digits_len - 1, 0, -1):
+
-            # print("len1", len1)
+
         #print("top_group_digits_len", top_group_digits_len)
         for len1 in range(top_group_digits_len-1, 0, -1):
             #print("len1", len1)
             code1 = top_group_digits[0: len1]
             ancestors.append(code1)
             ancestors_top_group_digits.append(len1)
             ancestors_groups.append(1)
-        if self.max_depth is None:
+        # print("След анализ на първата група: ancestors", ancestors)
-            self.max_depth = ancestors_len
+
-        elif ancestors_len > self.max_depth:
+
-            self.max_depth = ancestors_len
+
         ancestors_len = len(ancestors)
         for idx in range(ancestors_len):
             child = ancestors[idx]
             child_top_group_digits_len = ancestors_top_group_digits[idx]
             child_groups = ancestors_groups[idx]
             parent_idx = idx + 1
             if parent_idx < ancestors_len:  # Бащата присъства в списъка
                 parent = ancestors[parent_idx]  # Вземаме бащата от списъка
             else:  # Бащата не е в списъка
                 parent = ""  # Затова бащата е коренът
 
             if child in self.struct:
                 # Няма нужда са се минава нататък през родителите му, понеже те вече са вписани
-                if len(child) > 0 and child not in self.all_accs: # TODO -> НЕ СЪДЪРЖА ВСИЧКИ СМЕТКИ !!!
+                #print(f"Вече е вписано, че {child} има родител {parent}, пропускаме останалото родословие")
-                    self.all_accs.append(parent)
+
-                if len(parent) > 0 and parent not in self.all_accs:
+
-                    self.all_accs.append(parent)
+
                 self.top_digits[child] = child_top_group_digits_len
                 self.groups[child] = child_groups
         # print('ancestors', ancestors)
     def get_max_groups_count(self):
         return self.max_groups_count
 
     def get_top_group_max_digits_count(self):
         return self.top_group_max_digits_count
 
     def get_top_group_digits(self, code):
         return self.top_digits[code]
 
     def get_groups(self, code):
         return self.groups[code]
 
     # Връща дълбочината на дадена сметка в дървото
     def get_depth(self, code):  # TODO Izpolzwam 2
-    def get_max_depth(self):
+
-        return self.max_depth
+
         # Такава сметка има
         depth = 0
         next_code = code
         while next_code in self.struct:
             depth += 1
             next_code = self.struct[next_code]
 
         return depth
 
 
 
     def print_struct(self):     # TODO up_struct = children ????
         print('struct', self.struct) # struct {'10-100-20-25': '10-100-20', '10-100-20': '10-100', '10-100': '10', '10': '1', '1': ''}
-    def print_struct(self):  # TODO up_struct = children ????
+
-        print('struct', self.struct)  # struct {'10-100-20-25': '10-100-20', '10-100-20': '10-100', '10-100': '10', '10': '1', '1': ''}
+
         for key in self.struct:
             if self.struct[key] == self.struct[key]:
                 key_up_struct = self.struct[key]
                 if key_up_struct in up_struct:
                     up_struct[key_up_struct] += [key]
                 elif key_up_struct not in up_struct:
                     up_struct[key_up_struct] = [key]
         # Сортиране на децата -> List in value
         for parent_acc in up_struct:
             up_struct[parent_acc].sort()
 
         print('up_struct', up_struct)
 
 
     # Връща list с само преките деца на даден code
     def get_children(self, code):
 
         if self.children is None:
             self.children = {}
             # Ще бъде речник с изброени преки деца на всяка сметка {"150": ["150-1", "150-2", ...], ...}
             for child in self.struct:
                 parent = self.struct[child]
-        if code in self.children:  # Ако кодът има деца...
+
                     self.children[parent] = []
                 self.children[parent].append(child)
-        return []  # Затова връщаме празен списък
+
         if code in self.children: # Ако кодът има деца...
             return self.children[code]  # връшаме ги Връща лист !
-    def get_all_children(self, code, max_depth=None):
+
-        if max_depth is None:
+
-            max_depth = self.max_depth
+        return []   # Затова връщаме празен списък
 
     # Връща list с всички деца, внуци и т.н. на даден код
     def get_all_children(self, code, max_depth = 999):
         if max_depth == 0:
             return []
-        # print(f"АААААА {code} има за деца {children}")
+
         processed = []
         children = self.get_children(code)
-            # print(f"get_all_children() depth {depth}")
+        #print(f"АААААА {code} има за деца {children}")
         depth = 0
-            children_on_this_depth = 0
+
             children1 = []
             for child in children:
                 children1.append(child)
                 if child in processed:  # вече сме добавили преките деца на това дете
                     continue  # затова пропускаме
-                # print(f"Ниво {depth}: {child} има за деца {children2}")
+
-                children_on_this_depth += len(children2)
+                #print(f"Ниво {depth}: {child} има за деца {children2}")
                 processed.append(child)
                 for child2 in children2:
                     children1.append(child2)
-            if children_on_this_depth == 0:
+            #print(f"Заместваме {children} с {children1}")
             children = children1
             depth += 1
         return children
 
     def get_parent(self, acc_code):
         # print(f"acc_code {acc_code}")
-        if acc_code is None or acc_code == '':
+        # print('self.struct[acc_code]: ', self.struct[acc_code])
         if acc_code is None:
-        if acc_code in self.struct:  # Писано от мен
+
         print(self.struct)
         # if acc_code in self.struct[acc_code]: # Писано от Владо
-    def get_all_parents(self, acc_code):
+        if acc_code in self.struct: # Писано от мен
-        parents = []
+
-        # Почваме от даения код, вземаме родителя, после неговия родител и т.н. докато опрем в корена
+
     def get_ancestors(self, acc_code):
         ancestors = []
         # Почваме от даения код, вземаме родителя, после неговия родител и т.н.
         # докато опрем в корена
-                break  # няма повече родители
+
-            parents.append(parent)  # Добавяме родителя в списъка с предци
+
-            browse_code = parent
+
-        return parents
+
             	break   # няма повече родители
-    # Листа на дървото = тези които нямат деца = най-дълбоки деца
+            ancestors.push(parent)  # Добавяме родителя в списъка с предци
-    def get_leaves(self):
+        return ancestors
-        # всички които имат родители са KEY в struct
+
-        # всики които имат деца са VALUE в struct
+    # В TrialBalanceFilter на много места се искаме да знаем дали code1 е дете на code2.
-        # значи листа са тези които ги няма в стойностите, но ги има в ключовете
+    # Там правим сложни аналзи на групи цифри -- те трябва да се махнат.
-        values = self.struct.values() # list1
+    # ТАМ има self.acc_tree, което е обект от клас AccountTree
-        keys = self.struct.keys()  # list2
+    # AccountTree tрябва да се сдобие с методи като is_child() по-долу,
-        #leaves = има в keys, но ги няма в values
+    # kойто да отговаря на тоя въпрос като използва своя self.struct
-        leaves = set(keys).difference(values)
+    def is_child(self, child, parent):
-        return leaves
+        # Трябва да връша true или false
         pass
-    def get_leaves_bycode(self, list_accs: list):
+    def is_parent(self, child, parent):
-        list_leaves_bycode = []
+        # Трябва да връша true или false
-        # TODO -> Подавам код и проверяван дали е родител
+        pass
-        print('get_leaves_bycode list_accs: ', list_accs)
+
-        for leaf in list_accs:
+
-            is_parent = self.is_parent(leaf)
+
-            if not is_parent:
+
-                list_leaves_bycode.append(leaf)
+    acc_tree.add_code("100")
-        return list_leaves_bycode
+
     acc_tree.get_parent('100')
-    def get_all_deepest_parents(self):
+