tricc-oo 1.4.24__py3-none-any.whl → 1.4.26__py3-none-any.whl

tricc_oo/converters/tricc_to_xls_form.py

@@ -35,7 +35,7 @@ def get_export_name(node, replace_dots=True):
         node.gen_name()
         if isinstance(node, TriccNodeSelectOption):
                 node.export_name = node.name
-        elif node.last != True:
+        elif node.last == False:
             node.export_name = clean_name(node.name + VERSION_SEPARATOR + str(node.version), replace_dots=replace_dots)
         # elif node.activity.instance>1:
         #     if node.version:

tricc_oo/models/base.py

@@ -630,6 +630,8 @@ def not_clean(a):
 # @param list_or
 # @param and elm use upstream
 def clean_or_list(list_or, elm_and=None):
+    if TriccStatic(True) in list_or:
+        return [TriccStatic(True)]
     for a in list(list_or):
         if isinstance(a, TriccOperation) and a.operator == TriccOperator.OR:
             list_or.remove(a)
@@ -694,7 +696,7 @@ def simple_and_join(left, right):
         )
 
 def or_join(list_or, elm_and=None):
-    cleaned_list  = clean_or_list(list_or, elm_and)
+    cleaned_list  = clean_or_list(set(list_or), elm_and)
     if len(cleaned_list) == 1:
         return cleaned_list[0]
     elif len(cleaned_list)>1: 

tricc_oo/strategies/output/xls_form.py

@@ -616,10 +616,8 @@ class XLSFormStrategy(BaseOutPutStrategy):
                 if hasattr(node, 'expression') and (node.expression is None) and issubclass(node.__class__,TriccNodeCalculateBase):
                     node.expression = get_node_expressions(node, processed_nodes, process=kwargs.get('process', 'main '))
                     # continue walk
-                if issubclass(node.__class__, (TriccNodeDisplayModel, TriccNodeDisplayCalculateBase)):
+                if issubclass(node.__class__, (TriccNodeDisplayModel, TriccNodeDisplayCalculateBase, TriccNodeEnd)):
                     last_version =  set_last_version_false(node, processed_nodes)
-                    if not last_version:
-                        node.last = True
                 return True
         return False
     
@@ -635,8 +633,7 @@ class XLSFormStrategy(BaseOutPutStrategy):
                     # we don't overright if define in the diagram
                     if node.constraint is None:
                         if isinstance(node, TriccNodeSelectMultiple):
-                            node.constraint = TriccOperation(
-                                TriccOperator.OR,
+                            node.constraint = or_join(
                                 [
                                     TriccOperation(TriccOperator.EQUAL, ['$this', TriccStatic('opt_none')]),
                                     TriccOperation(TriccOperator.NOT, [

tricc_oo/visitors/tricc.py

@@ -74,7 +74,7 @@ def get_node_expressions(node, processed_nodes, process=None):
         expression = get_node_expression(node, processed_nodes=processed_nodes, is_calculate=is_calculate, process=process)
         
     if is_calculate:
-        if expression  and (not isinstance(expression, str) or expression != '') and  expression is not True  :
+        if expression  and (not isinstance(expression, str) or expression != '') and  expression is not True :
             num_expression = TriccOperation(
                 TriccOperator.CAST_NUMBER,
                 [expression]
@@ -96,10 +96,10 @@ def get_node_expressions(node, processed_nodes, process=None):
 def set_last_version_false(node, processed_nodes):
     node_name = node.name if not isinstance(node, TriccNodeEnd) else node.get_reference()
     #last_version = get_last_version(node_name, processed_nodes) if issubclass(node.__class__, (TriccNodeDisplayModel, TriccNodeDisplayCalculateBase, TriccNodeEnd)) and not isinstance(node, TriccNodeSelectOption)  else  None
-    last_version = processed_nodes.find_prev(node, lambda item: hasattr(item, 'name') and item.name == node.name and  issubclass(node.__class__, (TriccNodeDisplayModel, TriccNodeDisplayCalculateBase, TriccNodeEnd)) and not isinstance(node, TriccNodeSelectOption))
+    last_version = processed_nodes.find_prev(node, lambda item: item.id != node.id and hasattr(item, 'name') and item.name == node.name and  issubclass(node.__class__, (TriccNodeDisplayModel, TriccNodeDisplayCalculateBase, TriccNodeEnd)) and not isinstance(node, TriccNodeSelectOption))
     if last_version and getattr(node, 'process', '') != 'pause':
         # 0-100 for manually specified instance.  100-200 for auto instance 
-        node.version = get_next_version(node.name, processed_nodes, last_version.version + 1)
+        node.version = get_next_version(node.name, processed_nodes, last_version.version + 1, 0)
         last_version.last = False
         node.path_len = max(node.path_len, last_version.path_len + 1)
     return last_version
@@ -152,8 +152,7 @@ def get_version_inheritance(node, last_version, processed_nodes):
 def merge_expression(expression, last_version):
     datatype = expression.get_datatype()
     if datatype == 'boolean':
-        expression = TriccOperation(
-            TriccOperator.OR,
+        expression = or_join(
             [TriccOperation(TriccOperator.ISTRUE, [last_version]), expression]
         )
     
@@ -472,13 +471,9 @@ def generate_calculates(node,calculates, used_calculates,processed_nodes):
     if hasattr(node, 'save') and node.save is not None and node.save != '':
         # get fragments type.name.icdcode
         calculate_name=node.save   
-        if not isinstance(node, TriccNodeSelectYesNo) and  issubclass(node.__class__, (TriccNodeSelect)):
-            calc_node = get_count_node(node)
-            calc_node.path_len += 1
-            calc_node.name=calculate_name
-            calc_node.label =  "save select: " +node.get_name()        
-        elif node.name != calculate_name:
+        if node.name != calculate_name:
             calc_id = generate_id(f"autosave{node.id}")
+            
             calc_node = TriccNodeCalculate(
                 name=calculate_name,
                 id = calc_id,
@@ -487,23 +482,20 @@ def generate_calculates(node,calculates, used_calculates,processed_nodes):
                 activity = node.activity,
                 label =  "save: " +node.get_name(),
                 path_len=node.path_len+ 1,
-                last=True
+                last=True,
+                expression=get_node_expression(node,processed_nodes,True,True)
             )
-            node.activity.nodes[calc_node.id]=calc_node
+            node.activity.calculates.append(calc_node)
             last_version = set_last_version_false(calc_node, processed_nodes)
             if last_version:
-                get_version_inheritance(node, last_version, processed_nodes)
+                calc_node.expression = merge_expression(calc_node.expression, last_version)
             processed_nodes.add(calc_node)
-        logger.debug("generate_save_calculate:{}:{} as {}".format(calc_node.tricc_type, node.name if hasattr(node,'name') else node.id, calculate_name))
-        if isinstance(node, TriccNodeSelectYesNo):
-            yesNode =  node.options[0]
-            set_prev_next_node(yesNode,calc_node)
-        else:
-            set_prev_next_node(node,calc_node)
-        list_calc.append(calc_node)
-        #add_save_calculate(calc_node, calculates, used_calculates,processed_nodes)
-        for calc in list_calc:
-            node.activity.nodes[calc.id] = calc
+            logger.debug("generate_save_calculate:{}:{} as {}".format(calc_node.tricc_type, node.name if hasattr(node,'name') else node.id, calculate_name))
+            
+            list_calc.append(calc_node)
+            #add_save_calculate(calc_node, calculates, used_calculates,processed_nodes)
+            for calc in list_calc:
+                node.activity.nodes[calc.id] = calc
     return list_calc
 
 
@@ -965,7 +957,7 @@ def walkthrough_tricc_option(node, callback, processed_nodes, stashed_nodes, pat
                                                                         node_path = node_path.copy(), **kwargs)
 
 def get_next_version(name, processed_nodes, version=0, min=100):
-    return max(version, min,*[(getattr(n,'version',0) or getattr(n,'instance',0) or 0) for n in get_versions(name, processed_nodes)])
+    return max(version, min,*[(getattr(n,'version',None) or getattr(n,'instance',None) or 0) for n in get_versions(name, processed_nodes)])+1
 
 
 def get_data_for_log(node):
@@ -1505,7 +1497,7 @@ def get_node_expression( in_node, processed_nodes, is_calculate=False, is_prev=F
             if isinstance(node, TriccNodeMainStart):
                 expression =  get_applicability_expression(node.activity, processed_nodes, process, expression )
         elif isinstance(node, (TriccNodeActivityStart)):
-            return None
+            return TriccStatic(True)
         
     elif isinstance(node, TriccNodeWait):
         if is_prev:
@@ -1556,15 +1548,15 @@ def get_node_expression( in_node, processed_nodes, is_calculate=False, is_prev=F
             logger.critical(f"Rhombus without expression {node.get_name()}")
     elif is_prev and issubclass(node.__class__, TriccNodeDisplayCalculateBase):
         expression = TriccOperation(TriccOperator.ISTRUE, [node])
+    elif is_prev and is_calculate and (issubclass(node.__class__, TriccNodeSelect) or isinstance(node, TriccNodeSelectNotAvailable)):
+        expression = get_count_terms_details( node,  processed_nodes, is_calculate, negate, process)
     elif hasattr(node, 'expression_reference') and isinstance(node.expression_reference, TriccOperation):
         # if issubclass(node.__class__, TriccNodeDisplayCalculateBase):
         #     expression = TriccOperation(
         #         TriccOperator.CAST_NUMBER,
         #         [node.expression_reference])
         # else:    
-        expression = node.expression_reference
-    elif not is_prev and hasattr(node, 'relevance') and isinstance(node.relevance, TriccOperation):
-        expression = node.relevance     
+        expression = node.expression_reference  
     elif is_prev and isinstance(node, TriccNodeSelectOption):
         if negate:
             negate_expression = get_selected_option_expression(node, negate)
@@ -1584,9 +1576,12 @@ def get_node_expression( in_node, processed_nodes, is_calculate=False, is_prev=F
             negate_expression = get_calculation_terms(node, processed_nodes=processed_nodes, is_calculate=is_calculate, negate=True, process=process)
         else:
             expression = get_calculation_terms(node, processed_nodes=processed_nodes, is_calculate=is_calculate, process=process)
+    
+    elif (not is_prev or not ONE_QUESTION_AT_A_TIME) and hasattr(node, 'relevance') and isinstance(node.relevance, (TriccOperation, TriccStatic)):
+        expression = node.relevance  
     elif ONE_QUESTION_AT_A_TIME and is_prev and not is_calculate and hasattr(node, 'required') and node.required:
         expression = get_required_node_expression(node)
-    
+ 
     if expression is None:
         expression = get_prev_node_expression(node, processed_nodes=processed_nodes, is_calculate=is_calculate, process=process)
             # in_node not in processed_nodes is need for calculates that can but run after the end of the activity
@@ -1846,8 +1841,7 @@ def get_prev_node_expression( node, processed_nodes, is_calculate=False, exclude
         expression = expression_inputs[0]
     
     elif expression_inputs:
-        expression = TriccOperation(
-            TriccOperator.OR,
+        expression = or_join(
             expression_inputs
         )
         # if isinstance(node,  TriccNodeExclusive):
@@ -1874,7 +1868,28 @@ def get_activity_end_terms( node, processed_nodes, process=None):
 
 def get_count_terms( node, processed_nodes, is_calculate, negate=False, process=None):
     terms = []
+    
     for prev_node in node.prev_nodes:
+        term = get_count_terms_details( prev_node, processed_nodes, is_calculate, negate, process)
+        if term:
+            terms.append(term)
+    if len(terms) == 1:
+        return TriccOperation(
+            TriccOperator.CAST_NUMBER,
+            [terms[0]]
+        )
+    elif len(terms) > 0:
+        return TriccOperation(
+            TriccOperator.PLUS,
+            [
+                TriccOperation(
+                    TriccOperator.CAST_NUMBER,
+                    [term]
+                ) for term in terms
+            ]
+        )
+        
+def get_count_terms_details( prev_node, processed_nodes, is_calculate, negate=False, process=None):
         operation_none = TriccOperation(
             TriccOperator.SELECTED,
             [
@@ -1882,12 +1897,20 @@ def get_count_terms( node, processed_nodes, is_calculate, negate=False, process=
                 TriccStatic('opt_none')
             ]
         )
-        if isinstance(prev_node, TriccNodeSelectMultiple):
+        if isinstance(prev_node, TriccNodeSelectYesNo):
+            return TriccOperation(
+                TriccOperator.SELECTED,
+                [
+                    prev_node,
+                    TriccStatic(prev_node.options[0].name)
+                ]
+            )
+        elif issubclass(prev_node.__class__, TriccNodeSelect):
             if negate:
-                terms.append()
+                return
                 #terms.append(TRICC_SELECT_MULTIPLE_CALC_NONE_EXPRESSION.format(get_export_name(prev_node)))
             else:
-                terms.append(TriccOperation(
+                return TriccOperation(
                     TriccOperator.MINUS,
                     [
                         TriccOperation(
@@ -1902,23 +1925,22 @@ def get_count_terms( node, processed_nodes, is_calculate, negate=False, process=
                                 operation_none
                             ]
                         )
-                ]))
+                ])
                 #terms.append(TRICC_SELECT_MULTIPLE_CALC_EXPRESSION.format(get_export_name(prev_node)))
-        elif isinstance(prev_node, (TriccNodeSelectYesNo, TriccNodeSelectNotAvailable)):
-            terms.append(TriccOperation(
+        elif isinstance(prev_node, (TriccNodeSelectNotAvailable)):
+            return TriccOperation(
                 TriccOperator.SELECTED,
                 [
                     prev_node,
                     TriccStatic('1')
                 ]
-            ))
+            )
             #terms.append(TRICC_SELECTED_EXPRESSION.format(get_export_name(prev_node), '1'))
         elif isinstance(prev_node, TriccNodeSelectOption):
-            terms.append(get_selected_option_expression(prev_node, negate))
+            return get_selected_option_expression(prev_node, negate)
         else:
             if negate:
-                terms.append(
-                    TriccOperation(
+                return TriccOperation(
                         TriccOperator.CAST_NUMBER,
                         [
                             TriccOperation(
@@ -1939,10 +1961,9 @@ def get_count_terms( node, processed_nodes, is_calculate, negate=False, process=
                             )
                         ]
                     )
-                )
+                
             else:
-                terms.append(
-                    TriccOperation(
+                return TriccOperation(
                         TriccOperator.CAST_NUMBER,
                         [
                             get_node_expression(
@@ -1952,22 +1973,8 @@ def get_count_terms( node, processed_nodes, is_calculate, negate=False, process=
                                 is_prev=True,
                                 process=process)
                         ]
-                    ))
-    if len(terms) == 1:
-        return TriccOperation(
-            TriccOperator.CAST_NUMBER,
-            [terms[0]]
-        )
-    elif len(terms) > 0:
-        return TriccOperation(
-            TriccOperator.PLUS,
-            [
-                TriccOperation(
-                    TriccOperator.CAST_NUMBER,
-                    [term]
-                ) for term in terms
-            ]
-        )
+                    )
+    
         
     
 def get_add_terms( node, processed_nodes, is_calculate=False, negate=False, process=None):
@@ -2180,7 +2187,7 @@ def get_calculation_terms( node, processed_nodes, is_calculate=False, negate=Fal
     
 # Function that add element to array is not None or ''
 def add_sub_expression(array, sub):
-    if isinstance(sub, TriccOperation) or  sub:
+    if isinstance(sub, (TriccOperation, TriccStatic)):
         not_sub = negate_term(sub)
         if not_sub in array:
             # avoid having 2 conditions that are complete opposites
@@ -2188,6 +2195,8 @@ def add_sub_expression(array, sub):
             array.append(TriccStatic(True))
         else:
             array.append(sub)
+    else:
+        pass
     # elif sub is None:
     #     array.append(TriccStatic(True))
         

tricc_oo/visitors/xform_pd.py

@@ -173,7 +173,7 @@ def get_tasksstrings(hidden_names, df_survey):
 
 
 def get_task_js(form_id, calculate_name, title, form_types, hidden_names, df_survey, repalce_dots=False, task_title="'id: '+getField(report, 'g_registration.p_id')+'; age: '+getField(report, 'p_age')+getField(report, 'g_registration.p_gender')+' months; '+getField(report, 'p_weight') + 'kg; ' + getField(report, 'g_fever.p_temp')+'°'"):
-    task_name = f"{form_id}_{calculate_name}"
+    task_name = f"{form_id}"
     task_name_upper = task_name.upper()
 
     
@@ -181,17 +181,16 @@ def get_task_js(form_id, calculate_name, title, form_types, hidden_names, df_sur
 /* eslint-disable no-use-before-define */
 /* eslint-disable */
 
-const {{injectDataFromForm, isFormArrayHasSourceId}} = require('./stph-extras'); -> isFormArrayHasSourceId was missing from the imports
+const {{injectDataFromForm, isFormArrayHasSourceId}} = require('./stph-extras');
 
 const CASE_DATA = ['{"','".join(hidden_names)}'];
     
-const {{injectDataFromForm}} = require('./stph-extras');
 
 const {task_name_upper}_FORMS = ['{"','".join(form_types)}'];
 
 var task_title = "{task_title}"
 
-const {task_name_upper}_TASK_FORM = '{form_id}_{calculate_name}';
+const {task_name_upper}_TASK_FORM = '{form_id}';
 
 const {task_name}Content =  function (content, contact, report){{
 
@@ -213,9 +212,12 @@ function {task_name}ContactLabel (){{
 
 
 function {task_name}ResolveIf(contact, report, event, dueDate) {{
-  return isFormArrayHasSourceId( report, contact.reports, event, dueDate, {task_name_upper}_TASK_FORMS);
+  return isFormArrayHasSourceId( report, contact.reports, event, dueDate, {task_name_upper}_TASK_FORM);
 }}
 
+function {task_name}AppliesIf(contact, report, event, dueDate) {{
+  return report.{calculate_name};
+}}
 
 module.exports = {{
   {task_name_upper}_TASK_FORM,
@@ -223,6 +225,7 @@ module.exports = {{
   {task_name}Content,
   {task_name}ContactLabel,
   {task_name}ResolveIf,
+  {task_name}AppliesIf,
 }}
 // 
 //// to be copied in task
@@ -232,7 +235,8 @@ module.exports = {{
 //  {task_name_upper}_FORMS,
 //  {task_name}Content,
 //  {task_name}ContactLabel,
-//  {task_name}ResolveIf, }} = require('./{task_name}');
+//  {task_name}ResolveIf, 
+//  {task_name}AppliesIf, }} = require('./{task_name}');
 //
 //module.exports = [
 //
@@ -242,6 +246,7 @@ module.exports = {{
 //        title: 'diagnostic',
 //        appliesTo: 'reports',
 //        appliesToType: {task_name_upper}_FORMS,
+//        appliesIf: {task_name}AppliesIf,
 //        actions: [
 //            {{
 //                type: 'report',

{tricc_oo-1.4.24.dist-info → tricc_oo-1.4.26.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tricc-oo
-Version: 1.4.24
+Version: 1.4.26
 Summary: Python library that converts CDSS L2 in L3
 Project-URL: Homepage, https://github.com/SwissTPH/tricc
 Project-URL: Issues, https://github.com/SwissTPH/tricc/issues

{tricc_oo-1.4.24.dist-info → tricc_oo-1.4.26.dist-info}/RECORD

@@ -7,7 +7,7 @@ tricc_oo/converters/codesystem_to_ocl.py,sha256=-ZKMBeIvzgqmhJfnn6ptuwpnHQtuE-fC
 tricc_oo/converters/cql_to_operation.py,sha256=bsVD4HO5Zr2clHuIWz86gIUnI7aZ676IXDK5S7x32_o,14439
 tricc_oo/converters/datadictionnary.py,sha256=WWKcTtKLfc4aduHcDBhr4JSfU2NqRMaslwX-wdZPIAw,3968
 tricc_oo/converters/drawio_type_map.py,sha256=6ZcnQMtBU1dhf_NP_s0iX1DvRf0qS7-3UAe_WAPFVoQ,7027
-tricc_oo/converters/tricc_to_xls_form.py,sha256=lfnM-piCH9EyoOT89VDi1eRGUbMWgpzbvDXZgfEYmrM,2326
+tricc_oo/converters/tricc_to_xls_form.py,sha256=bJVd-FLrivrCxGI6mO2i0V7GVVuJZdaDuwcEf3gHNR8,2327
 tricc_oo/converters/utils.py,sha256=UyndDORsDbRV5-gYW-yInK5ztjtYdeCw6K-mrYr1Emk,1688
 tricc_oo/converters/xml_to_tricc.py,sha256=IO6jL1ljhrkWnPTe5EsQCfJ4wUoYitLH2P7TIJm4A9I,37457
 tricc_oo/converters/cql/cqlLexer.py,sha256=t0-QvDv5kxCiBZJ9SfDumFOgnRSry_HJpakBZV224Ig,49126
@@ -15,7 +15,7 @@ tricc_oo/converters/cql/cqlListener.py,sha256=ketvj7XvO7t047S6A3_gTPvp2MlYk1bojm
 tricc_oo/converters/cql/cqlParser.py,sha256=hIUdR907WX24P2Jlrxk-H0IT94n51yh_ZsCmwQhnFas,414730
 tricc_oo/converters/cql/cqlVisitor.py,sha256=SWSDIqVYBhucR4VgLn_EPNs7LV9yCqsOmzFZ0bmRSGc,33865
 tricc_oo/models/__init__.py,sha256=Rdk1fsNXHrbmXTQD1O7i0NC_A6os648Ap6CtWRliOg8,92
-tricc_oo/models/base.py,sha256=RE4J98-zzKcB5a0gm4EPjbMjcHEuM17lkIMRAxUPtyQ,24309
+tricc_oo/models/base.py,sha256=6YU4FrUT4gE6WlERR1OPvQpq3bBKzG38I68_SZmaAao,24386
 tricc_oo/models/calculate.py,sha256=Bw7OGa4OYxHP529wA23CZftMYDL_CA0SPQ0j1IFyTNA,7456
 tricc_oo/models/lang.py,sha256=SwKaoxyRhE7gH_ZlYyFXzGuTQ5RE19y47LWAA35zYxg,2338
 tricc_oo/models/ocl.py,sha256=ol35Gl1jCBp0Ven0yxOKzDIZkVL5Kx9uwaR_64pjxKI,8931
@@ -32,15 +32,15 @@ tricc_oo/strategies/input/base_input_strategy.py,sha256=-GQ_xRvJXzn-q_eT8R-wtFOT
 tricc_oo/strategies/input/drawio.py,sha256=glLts9whixJM4HOV_GAWAK8az_H-eo9aeFAQbn99-4c,13362
 tricc_oo/strategies/output/base_output_strategy.py,sha256=WiJwqm4g_x-rbksrjoE0ABhNMtM0_fAMoPH34RKZdc0,7173
 tricc_oo/strategies/output/spice.py,sha256=s_COahyYCoc4Xv5TGh_AW9evDOW6GOex0Xwa_JWeLsI,11280
-tricc_oo/strategies/output/xls_form.py,sha256=DuDmTuM5h3Njo0RBcQQq1dRKr4XMVJJzZtaZdfJ1T6I,31130
+tricc_oo/strategies/output/xls_form.py,sha256=nUK_eAzlHDLliq2lIkFhOkn1zVTPGTUElfuN9FB9Yrc,31005
 tricc_oo/strategies/output/xlsform_cdss.py,sha256=8oLlgS1Hr6IVvI0O71kIk5oIKXbt2lPVc1SZIjzcSTc,9452
 tricc_oo/strategies/output/xlsform_cht.py,sha256=SWu1GKI5PScSX420RiVVaCNCTINeTeLpCoX-zXQIhUE,19486
 tricc_oo/strategies/output/xlsform_cht_hf.py,sha256=0D_H68a2S7oLKJENEePaRGIocrRIF45BofHlLOtGsKo,2206
 tricc_oo/visitors/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tricc_oo/visitors/tricc.py,sha256=-tWEo2xxVAvQoy53f-2UDIFDhqMxguDBHNQMclg7GHs,97700
+tricc_oo/visitors/tricc.py,sha256=HELyOpFo_-AHsegjK0tbnyRtWOhtK9sPr3r7uN8GsEs,98055
 tricc_oo/visitors/utils.py,sha256=Gol4JNozPEd30Q1l8IPIPhx5fqVyy9R81GofGVebgD8,484
-tricc_oo/visitors/xform_pd.py,sha256=H8x-72EdyT_-QgHGQN-ZAe-wc7tLtJGCM9waA64mz3M,9424
-tricc_oo-1.4.24.dist-info/METADATA,sha256=1TpiMwhrBuSmKEuUHptgc9RiIwPp_pntudZnVFvPcnY,7878
-tricc_oo-1.4.24.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
-tricc_oo-1.4.24.dist-info/top_level.txt,sha256=NvbfMNAiy9m4b1unBsqpeOQWh4IgA1Xa33BtKA4abxk,15
-tricc_oo-1.4.24.dist-info/RECORD,,
+tricc_oo/visitors/xform_pd.py,sha256=HfcpbeeW--Q1wrRrF_uMoPATkzUxMGO5KvXtlPMG31o,9474
+tricc_oo-1.4.26.dist-info/METADATA,sha256=DXqZoqrx1dWylZpGBaQJKDHQzKWWRIoCwLFCNt2DLqs,7878
+tricc_oo-1.4.26.dist-info/WHEEL,sha256=zaaOINJESkSfm_4HQVc5ssNzHCPXhJm0kEUakpsEHaU,91
+tricc_oo-1.4.26.dist-info/top_level.txt,sha256=NvbfMNAiy9m4b1unBsqpeOQWh4IgA1Xa33BtKA4abxk,15
+tricc_oo-1.4.26.dist-info/RECORD,,

{tricc_oo-1.4.24.dist-info → tricc_oo-1.4.26.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.7.1)
+Generator: setuptools (80.8.0)
 Root-Is-Purelib: true
 Tag: py3-none-any