pydpm_xl 0.1.39rc32__py3-none-any.whl → 0.2.1__py3-none-any.whl

pydpm_xl-0.2.1.dist-info/RECORD

@@ -0,0 +1,88 @@
+py_dpm/__init__.py,sha256=SfCnl2zNEvxu7CWIE2i9T-IlPrYBwynS4qSBFRloO2E,1858
+py_dpm/api/__init__.py,sha256=g0w2FOtETU1ZMuhGnbdgBmmTZwmWoBtBEDmkLR1t8sc,1824
+py_dpm/api/explorer.py,sha256=1dBc2ZidcAR5DfPEBRiyVk54Xv9u_G9mU66u7PA9Z-E,86
+py_dpm/api/semantic.py,sha256=QT0znXXa4ihqk4GmlmJQrdceCRy1o_3J17koW6rT5PE,1304
+py_dpm/api/dpm/__init__.py,sha256=FfyTxv29mxIrdw_y7QOdwwf8p4F9YsdiJ_H7HfL2gJo,528
+py_dpm/api/dpm/data_dictionary.py,sha256=g0h6Yfschz7rboYly9LTbP-2SS5UxltU3AXu0v0tqrU,29457
+py_dpm/api/dpm/explorer.py,sha256=gW2RC59XwGl9YbEA-M4syHAs6MvqPWVw4wR_XdVFJ4Y,7888
+py_dpm/api/dpm/hierarchical_queries.py,sha256=X4AbpsWy3iItOTVIdVbtaTmRgOHPf0Y64Ig-_377uns,4054
+py_dpm/api/dpm/migration.py,sha256=9FT7zzz4QdUIRR6MD01gMODBtfq9HH_RF4hRgZqMcZc,2404
+py_dpm/api/dpm/operation_scopes.py,sha256=Vw9cdPiFM7uCsQyMY1AgT5XhHbxFcVeMwIcIXANuty4,48486
+py_dpm/api/dpm_xl/__init__.py,sha256=rjiIf9XDi2IGf0G_LiOWp29e5ANyoREfzl5Z5phJU_8,603
+py_dpm/api/dpm_xl/ast_generator.py,sha256=-wOgUEM1DMpyVwflkplLr7BOZFfjaDeXi-R_PLhsAxo,16160
+py_dpm/api/dpm_xl/complete_ast.py,sha256=XmXvE1zWLxL732FvyUpK4WffKwZSrw5yrzJI-QGOpFI,24341
+py_dpm/api/dpm_xl/semantic.py,sha256=Buo_t-sEv65r6RmYDy1xkCWGlU2pB2WQsDM-X-FX4cc,13629
+py_dpm/api/dpm_xl/syntax.py,sha256=Ke_kKd9ModoJ6siL3GPT9j9QClmopryCRcdDAT3M5-E,5954
+py_dpm/cli/__init__.py,sha256=UrfGHoQ0sZLjWfA0hoOoI4iTrn-bjr2f9Q8wDWd5nMo,133
+py_dpm/cli/main.py,sha256=Cu04d3hpv0UdcROdkvpNipNfiAkde59YCbPu0gKKCYA,22444
+py_dpm/cli/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+py_dpm/dpm/__init__.py,sha256=moagUo5Gxf24-Tl9FL_3n2wmVoD_oXtpC-YIGktH_rc,212
+py_dpm/dpm/migration.py,sha256=ivO_ObvKzVomTns6qfo-o5FuciWxkXbMd_gJ4_tu7Xc,14110
+py_dpm/dpm/models.py,sha256=mk0zLUpPHZn5DN2iIFsZ4dJUjgT5b4rroD_Q8W-o_ns,124751
+py_dpm/dpm/utils.py,sha256=JNdAeOXjzQtye94jLPRHHGUMcvkGtTsjA5HFl92rWig,12783
+py_dpm/dpm/queries/base.py,sha256=EddMeJMwtp63DyyIFO7_XxGvdlCtJQWWpeOVImlKp4I,3648
+py_dpm/dpm/queries/basic_objects.py,sha256=JOXC235lMDfVENrFAhZAl7_nqePJ4RrwJhFF0WDyk0M,955
+py_dpm/dpm/queries/explorer_queries.py,sha256=Co8CzdzlDrOL5-ZxY7_HoHPaP_j-xjLDSsB8EKT5aC8,13034
+py_dpm/dpm/queries/filters.py,sha256=fxC2KLYpIvtmuyuJFb0te2ULiyDnQBZfVM79VQnr6qA,4901
+py_dpm/dpm/queries/glossary.py,sha256=2SqKZghQTw-E8NWwHebDHuDC8BC389fGe-0UBIVfJ8Q,1571
+py_dpm/dpm/queries/hierarchical_queries.py,sha256=FYO2p_OxZioynXW4nGCQ3UG3p3uzE28KdsmMaQSk1wk,31538
+py_dpm/dpm/queries/tables.py,sha256=ZaUwvQzj5EXR7BVv2VLYZ7Iii3aMFMlZ3rX25NtBuMg,4411
+py_dpm/dpm_xl/__init__.py,sha256=fN3AvMthyaVC893iza5IMzi3uVuLer411WdmKor6tY4,158
+py_dpm/dpm_xl/semantic_analyzer.py,sha256=vZjtEzCkGNZN20EoU8yDMee8vIwRhDxvN5-JhZFTFhI,15746
+py_dpm/dpm_xl/symbols.py,sha256=XSAiFSffxfPcnGdEDYEMjJrrhEJeuNIeasmHBp5C5Fc,7637
+py_dpm/dpm_xl/ast/__init__.py,sha256=S3ybJrA-IlLkzoO0VdAadBifg6ESn550B1m-TXzSiEE,329
+py_dpm/dpm_xl/ast/constructor.py,sha256=X8l0hedF2HDRSmmT9N0gkFs7ERS6xymvGHWQdtTWyOM,22204
+py_dpm/dpm_xl/ast/ml_generation.py,sha256=Lw_1Btln2x1ewD9xH-2Ea4NJJP3PIqFoivWASX3lcIM,25263
+py_dpm/dpm_xl/ast/module_analyzer.py,sha256=ZnldoYn-s41UMiJpcAV6hjIwH6fssZeOpc564epngg8,2872
+py_dpm/dpm_xl/ast/module_dependencies.py,sha256=tbCqoDcE1n1lJOjtbpD3rNPkXrLk-k2rM5zyVwmsNpc,8355
+py_dpm/dpm_xl/ast/nodes.py,sha256=5ob8MsCW0fPZgz9yP_6IgVTH2SGeoTk5VncJuQ2SgrE,25035
+py_dpm/dpm_xl/ast/operands.py,sha256=xe3MwgJzqxKPzyik1IjAtHqCgBBv_N3rQXqNtAVRDpw,21099
+py_dpm/dpm_xl/ast/template.py,sha256=QhYm7Jh_a-ws3kSmf0hqXFLzB_quO9GgKcmcFe22_fg,3045
+py_dpm/dpm_xl/ast/visitor.py,sha256=yL9UpPMQlq8ToHR8COyFYpuSChnDRjnkQHbCyYX0tsY,509
+py_dpm/dpm_xl/ast/where_clause.py,sha256=g3cslQ8vmlm0doqQ_ghjXzhzItc_xlC_bQ9odn87FGk,328
+py_dpm/dpm_xl/grammar/__init__.py,sha256=NmIQzgGc_4AzAOuLiQUSY9JsEG9h0hYCpw14kmKREME,551
+py_dpm/dpm_xl/grammar/generated/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+py_dpm/dpm_xl/grammar/generated/dpm_xlLexer.interp,sha256=ump1PKaPcRFlKTuKQSeBm6407x90lmSky1HP8KWfpjI,56920
+py_dpm/dpm_xl/grammar/generated/dpm_xlLexer.py,sha256=d2iJEDuYiizEYErMOfEEAfIl1ObORTAtizwSUH0PpYM,67560
+py_dpm/dpm_xl/grammar/generated/dpm_xlLexer.tokens,sha256=-Pj5UlkputKM9b9kMQTLeDCcGIMwAOEeXF8aKiBf30I,1246
+py_dpm/dpm_xl/grammar/generated/dpm_xlParser.interp,sha256=aBhwBzsukwdyNGBr7YI9Bgnuf3aUroBMsoGn-UH_LHQ,17617
+py_dpm/dpm_xl/grammar/generated/dpm_xlParser.py,sha256=65wE9zBnB4f-ELCCcjkyGRjcn_ef0Yd4_4n0qlcv79I,203789
+py_dpm/dpm_xl/grammar/generated/dpm_xlParser.tokens,sha256=-Pj5UlkputKM9b9kMQTLeDCcGIMwAOEeXF8aKiBf30I,1246
+py_dpm/dpm_xl/grammar/generated/dpm_xlParserListener.py,sha256=7EDpt2QwuvieqZx1yRLirF_sLaWSkAoM3PjpegQHSLs,24895
+py_dpm/dpm_xl/grammar/generated/dpm_xlParserVisitor.py,sha256=cl6oHKFH0Zr5S1FySykygOojG0CvcLmVUj1vfKmVoMI,14886
+py_dpm/dpm_xl/grammar/generated/listeners.py,sha256=mb7EOwZF_6qExdbUxrZDmXvykJBMlafGoxrPWpY1rz0,334
+py_dpm/dpm_xl/operators/__init__.py,sha256=Y9LmdMFs3k-3IXlpyhH9HYjnN2IZqk6vweVinAyAL0s,553
+py_dpm/dpm_xl/operators/aggregate.py,sha256=4AgPqrYcNYwUkq2_LgYg9CIsYzyeRiBLtQUiU56ePl8,4905
+py_dpm/dpm_xl/operators/arithmetic.py,sha256=FOI3Ielr-_hjmqx34zaK7OJVL1PIZkciQs2A5_swOfw,1775
+py_dpm/dpm_xl/operators/base.py,sha256=hy7_bie5oi5UzHISMVUvFjp6nbsh1btr-x0SyLQfAgM,18899
+py_dpm/dpm_xl/operators/boolean.py,sha256=8PYZEcZ9Pby7-xFeZXTjwAv3-rSo4NXwFDbasUbqKbo,520
+py_dpm/dpm_xl/operators/clause.py,sha256=DjD0Ez5JNaOhXCDZWYRjhK_9SZ3FIV0za5QsA7T9LGI,8625
+py_dpm/dpm_xl/operators/comparison.py,sha256=yMlq6SXh7H3Gydr15oX8UWBjjJMgTuh_ATQmrbeUHZ8,1156
+py_dpm/dpm_xl/operators/conditional.py,sha256=3XNPkVAJsETe0-Ua32nOxadzILqScQQ5Fc8eImEU5Pk,17264
+py_dpm/dpm_xl/operators/string.py,sha256=1exolNby9uaVucTr8Q8Mq2RtfoxZiVP9ORtBYnas5ZM,525
+py_dpm/dpm_xl/operators/time.py,sha256=9MXxvTYsQgwQGJ0o7hF3BtDekxWvUq_cSS95zUCxOvE,2240
+py_dpm/dpm_xl/types/__init__.py,sha256=GU5h5dRFabBDLpnKm-UAUDuOAfNFOzauS5rAgcOqMq0,294
+py_dpm/dpm_xl/types/promotion.py,sha256=NG50ETtTgh0-jYbSfoiGPpgtFYHwcV0cSXUHDbwd5Sw,9585
+py_dpm/dpm_xl/types/scalar.py,sha256=H-9asP2CynqWJ3WtRwjARjbQMWAXjTBdWryZch1ON_M,6878
+py_dpm/dpm_xl/types/time.py,sha256=MmxsHn9sqBCQ-YkTKlGn-yow-Y-XVMRvrUEthqhT0JM,11379
+py_dpm/dpm_xl/utils/__init__.py,sha256=4-jXa7AdHjx2DpikAzjZVKqBktdrHgSAx6pibb4sM_k,331
+py_dpm/dpm_xl/utils/data_handlers.py,sha256=a0E-IaP_-CDKLcj-Gt2ggAziKIOUiwnT2D9IkWCS68o,4402
+py_dpm/dpm_xl/utils/operands_mapping.py,sha256=LG0hPlUuTM2X2uWOtiD6HkmNeDEJkWJ8gV-Fxej_8QM,2241
+py_dpm/dpm_xl/utils/operator_mapping.py,sha256=BFgbVbSCSuutFNHJ4gtgm5VuG38pcl8Kmfi-sefg6JU,1913
+py_dpm/dpm_xl/utils/scopes_calculator.py,sha256=nCx2mz_qtw61BESp38ORQYlF2uRT8SyUKawSX9OQljM,17832
+py_dpm/dpm_xl/utils/serialization.py,sha256=LPcmudFfzHeEjIIr57kr5BvGPZbxshOAAeUYOrLl7XM,32482
+py_dpm/dpm_xl/utils/tokens.py,sha256=VRIrPDi5ttwgH-on5Qt4-l4ho4bLA755-nfTalponcA,3496
+py_dpm/dpm_xl/validation/__init__.py,sha256=pzSTkLzUgK16XsV_maXn__erzs0blDBDRApuRWJwwMs,250
+py_dpm/dpm_xl/validation/generation_utils.py,sha256=2UvYorpLor-8PiEUTWFFVr-xEzKjxQzZrLXz3lvedPk,22655
+py_dpm/dpm_xl/validation/property_constraints.py,sha256=d95p2LxIGGmtGJBz0X14Z4LsS404fvO61VHeAJkN8V8,8272
+py_dpm/dpm_xl/validation/utils.py,sha256=2dV23OJfhDbLYTKkwTUVsXaQeO8zJUs9LbjDXcO5OO4,4196
+py_dpm/dpm_xl/validation/variants.py,sha256=LM_2U_sCf8rnlUyt6k4WQwSKj5eTJLt4Ba8q9VVi4kg,13824
+py_dpm/exceptions/__init__.py,sha256=yDERfUxYW7NUUEiTQChGpuJx6abr7IDe2XUpwVFPtvM,416
+py_dpm/exceptions/exceptions.py,sha256=6S3p-_i5O1oStvSMixt_JQG0xwTeSfBcdzrwL8yBy6Q,2413
+py_dpm/exceptions/messages.py,sha256=UwY6QIK8c-POcDCc9HYbZFGArCIYAanUGNh2LNKPx3U,7534
+pydpm_xl-0.2.1.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+pydpm_xl-0.2.1.dist-info/METADATA,sha256=rUtdLeAJq0dbweFf9b5YXGC2wTPSU73pGuCgUyaek4Y,7974
+pydpm_xl-0.2.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pydpm_xl-0.2.1.dist-info/entry_points.txt,sha256=6DDmBfw-AjtgvMHgq_I730i_LAAs_7-N3C95HD_bRr4,47
+pydpm_xl-0.2.1.dist-info/top_level.txt,sha256=495PvWZRoKl2NvbQU25W7dqWIBHqY-mFMPt83uxPpcM,7
+pydpm_xl-0.2.1.dist-info/RECORD,,

pydpm_xl-0.2.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+pydpm = py_dpm.cli.main:main

py_dpm/Utils/utils.py

@@ -1,2 +0,0 @@
-START_RELEASE_ID_EBA = None
-START_RELEASE_ID_EIOPA = 1020000001

py_dpm/ValidationsGeneration/Utils.py

@@ -1,364 +0,0 @@
-import json
-import warnings
-from datetime import datetime
-from http.client import BAD_REQUEST, INTERNAL_SERVER_ERROR
-from pathlib import Path
-
-import pandas as pd
-
-from py_dpm.Exceptions.exceptions import ScriptingError, SemanticError
-from py_dpm.models import OperationVersion, SubCategory, TableVersionCell, ViewReportTypeOperandReferenceInfo
-from py_dpm.db_utils import get_session
-
-
-def format_table_code(code: str):
-    if not code or pd.isna(code):
-        return None
-    code = code.replace(' ', '_')
-    return code
-
-def assing_sign(formula):
-    if "<" in formula:
-        return "negative" # negative
-    elif ">" in formula:
-        return "positive" # positive
-    else:
-        return None
-
-
-def read_external_sign_data(**kwargs):
-    path = Path(__file__).parent / 'utils_report' / 'external_data'
-
-    eba_rules = path / 'EBA_Validation_Rules_2022-12-12.xlsx'
-    sht = '3.2(3.2.1, 3.2.2)'  # wb['v3.1(3.1.1)']  # the last one at 21/06/2022
-
-    eba_df = pd.read_excel(eba_rules, sheet_name=sht)
-    sign_validations = eba_df[eba_df['Type'] == 'Sign']
-    sign_validations['Table Code'] = sign_validations['T1'].map(lambda x: x.replace(' ', '_'))#map(format_table_code)
-    sign_validations["Sign"] = sign_validations["Formula"].map(assing_sign)
-    sign_validations = sign_validations[["Table Code", "Sign", "ID"]]
-    update_sign_db(sign_validations)
-    return sign_validations
-
-
-def update_sign_db(sign_validations):  # TODO: this does not work because DDL restrictions
-    session = get_session()
-    # sign_validations =  read_external_sign_data()
-    neg_tables = sign_validations[sign_validations["Sign"]=='negative']["Table Code"].unique().tolist()
-    pos_tables = sign_validations[sign_validations["Sign"]=='positive']["Table Code"].unique().tolist()
-    all_neg_table_version_ids = TableVersionCell.get_sign_query(session=session, sign=neg_tables)
-    all_pos_table_version_ids = TableVersionCell.get_sign_query(session=session, sign=pos_tables)
-    for table_version in all_neg_table_version_ids:
-        table_version.Sign = "negative"
-        session.commit()
-    for table_version in all_pos_table_version_ids:
-        table_version.Sign = "positive"
-        session.commit()
-
-    # session.commit()
-    session.close()
-
-def _error_to_dict(error):
-    if isinstance(error, SemanticError):
-        status = BAD_REQUEST
-        message_error = error.args[0]
-        error_code = error.args[1]
-    elif isinstance(error, SyntaxError):
-        status = BAD_REQUEST
-        message_error = error.args[0]
-        error_code = "Syntax"
-    elif isinstance(error, ScriptingError):
-        status = BAD_REQUEST
-        message_error = error.args[0]
-        error_code = error.args[1]
-    else:
-        status = INTERNAL_SERVER_ERROR
-        message_error = str(error)
-        now = datetime.now()
-        warnings.warn(f"[{now}] Unhandled exception:\n{error}", RuntimeWarning)
-        error_code = "Other"
-
-    return status, message_error, error_code
-
-
-class ExternalData:
-
-    def __init__(self):
-        self.proposed_rules, self.rejected_rules = self.read_external_data()
-
-    def read_external_data(self, **kwargs):
-        path = Path(__file__).parent / 'utils_report' / 'external_data'
-
-        proposed_rules_path = path / 'out_put_proposed_rules.xlsx'
-        rejected_rules_path = path / 'RejectedRuleProposals.csv'
-        proposed_rules = pd.read_excel(proposed_rules_path)
-        rejected_rules = pd.read_csv(rejected_rules_path, encoding='latin-1')
-        return proposed_rules, rejected_rules
-
-    @staticmethod
-    def get_expression_from_code(code: str):
-        if not code or pd.isna(code):
-            return None
-        sql_session = get_session()
-        expression = OperationVersion.get_operations_from_code(sql_session, code)
-        expression = expression["Expression"].iloc[0]  # TODO check if there is more than one expression take the last one maybe
-        sql_session.close()
-        return expression
-
-    @classmethod
-    def create_report(cls, report_df:pd.DataFrame, info_dict:dict, path:Path, name_report:str):
-        path_info = path / f"{name_report}_info.json"
-        path_validations = path / f"{name_report}_validations.csv"
-        report_df.to_csv(path_validations, index=False)
-        with open(path_info, 'w') as f:
-            f.write(json.dumps(info_dict))
-
-
-class ExternalDataHierarchies(ExternalData):
-
-    def __init__(self):
-        super().__init__()
-        # self.proposed_rules = self.proposed_rules.rename(columns={'HierarchyCode':'Hierarchy Code'})
-        self.proposed_rules = self.proposed_rules.dropna(subset=['Hierarchy Code']).reset_index(drop=True)
-        self.rejected_rules = self.rejected_rules.dropna(subset=['HierarchyCode']).reset_index(drop=True)
-
-    def get_hierarchy_subcategory(self, subcategory_code):
-        proposed_rules, rejected_rules = self.proposed_rules, self.rejected_rules
-
-        proposed_rules = proposed_rules[proposed_rules['Hierarchy Code'] == subcategory_code]
-        rejected_rules = rejected_rules[rejected_rules['HierarchyCode'] == subcategory_code]
-
-        return proposed_rules, rejected_rules
-
-    def compare_all_hierarchies_report(self, validations: list):
-        total_number_of_validations_created = 0
-        total_number_of_validations_proposed = 0
-        total_number_of_validations_rejected = 0
-        total_matches_codes = 0
-        total_duplicated_codes = 0
-        total_codes_dont_match_with_proposed = 0
-        total_missing_codes = 0
-        total_expressions_dont_match_with_proposed = 0
-        sql_session = get_session()
-        subcategory_codes = SubCategory.get_codes(session=sql_session)
-        sql_session.close()
-        subcategory_codes = [subcategory_code[0] for subcategory_code in subcategory_codes]
-        total_info = {}
-        total_merged = pd.DataFrame()
-        for subcategory_code in subcategory_codes:
-            validations_subcategory = [elto for elto in validations if elto['subcategory_code'] == subcategory_code]
-            merged, info = self.compare_hierarchies_report(validations_subcategory, subcategory_code)
-            total_merged = pd.concat([total_merged, merged])
-            for key, value in info.items():
-                total_info[key] = value
-                total_number_of_validations_created += value["number_of_validations_created"]
-                total_number_of_validations_proposed += value["number_of_validations_proposed"]
-                total_number_of_validations_rejected += value["number_of_validations_rejected"]
-                total_matches_codes += len(value["matches_codes(generated_expressions)"])
-                if "errors" in value.keys():
-                    total_duplicated_codes += len(value["errors"]["duplicated_codes"])
-                    total_codes_dont_match_with_proposed += len(value["errors"]["codes_dont_match_with_proposed"])
-                    total_missing_codes += len(value["errors"]["missing_codes"])
-                    total_expressions_dont_match_with_proposed += len(value["errors"]["expressions_dont_match_with_proposed"])
-
-        # aditional actions on total info
-        description = {}
-        description["total_number_of_validations_created"] = total_number_of_validations_created
-        description["total_number_of_validations_proposed"] = total_number_of_validations_proposed
-        description["total_number_of_validations_rejected"] = total_number_of_validations_rejected
-        description["total_matches_codes(generated_expressions)"] = total_matches_codes
-        description["total_duplicated_codes"] = total_duplicated_codes
-        description["total_codes_dont_match_with_proposed"] = total_codes_dont_match_with_proposed
-        description["total_missing_codes"] = total_missing_codes
-        description["total_expressions_dont_match_with_proposed"] = total_expressions_dont_match_with_proposed
-        final_info = {}
-        final_info["resume"] = description
-        final_info["subcategories"] = total_info
-
-        return total_merged, final_info
-
-    def compare_hierarchies_report(self, validations: list, subcategory_code: str):
-        proposed, rejected = self.get_hierarchy_subcategory(subcategory_code=subcategory_code)
-        proposed_specific = pd.DataFrame(columns=['ID', 'Formula', 'ProposedAction', 'Review Action', 'Hierarchy Code']) if proposed.empty else proposed[['ID', 'Formula', 'ProposedAction', 'Review Action', 'Hierarchy Code']]
-        rejected_specific = pd.DataFrame(columns=['ID', 'Formula', 'ProposedAction', 'Review Action', 'Hierarchy Code']) if rejected.empty else rejected[['ID', 'Formula', 'ProposedAction', 'ReviewAction', 'HierarchyCode']].rename(columns={'HierarchyCode':'Hierarchy Code', 'ReviewAction':'Review Action'})
-        info = {}
-        errors = {}
-        errors[subcategory_code] = {}
-        errors[subcategory_code]['duplicated_codes'] = []
-
-        proposed_codes = proposed_specific[~proposed_specific['ID'].isna()]["ID"].unique().tolist()
-        rejected_codes = rejected_specific['ID'].unique().tolist()
-        total_external = pd.concat([proposed_specific, rejected_specific])
-        total_external_codes = total_external['ID'].unique().tolist()
-        # validations_codes
-        validations_codes = []
-
-        [validations_codes.extend(elto['operation_code']) for elto in validations]
-
-        if len(validations_codes) != len(set(validations_codes)):
-            errors[subcategory_code]['duplicated_codes'] = list(set([code for code in validations_codes if validations_codes.count(code) > 1]))
-            validations_codes = list(set(validations_codes))
-
-        errors[subcategory_code]['codes_dont_match_with_proposed'] = [code for code in validations_codes if code not in total_external_codes]  # TODO
-        errors[subcategory_code]['missing_codes'] = [code for code in proposed_codes if code not in validations_codes]
-
-        #create comparative report
-        #first adapt validations
-        validations_to_df = []
-        errors[subcategory_code]['expressions_dont_match_with_proposed'] = []
-
-        for elto in validations:
-            is_duplicated = False
-            if len(elto['operation_code']) == 0:
-                if elto['expression'] not in errors[subcategory_code]['expressions_dont_match_with_proposed']:
-                    errors[subcategory_code]['expressions_dont_match_with_proposed'].append(elto['expression'])
-                validations_to_df.append(
-                    {'code':None, 'expression':elto['expression'], 'status':elto['status'],
-                    'subcategory_code':subcategory_code, 'is_duplicated':is_duplicated
-                    }
-                )
-            if len(set(elto['operation_code'])) > 1:
-                is_duplicated = True
-                errors[subcategory_code]['duplicated_codes'].extend(elto['operation_code'])
-
-            for op_code in elto['operation_code']:
-                validations_to_df.append(
-                    {'code':op_code, 'expression':elto['expression'], 'status':elto['status'],
-                    'subcategory_code':subcategory_code, 'is_duplicated':is_duplicated
-                    }
-                )
-
-        info[subcategory_code] = {'number_of_validations_created':len(validations)}
-        info[subcategory_code]['number_of_validations_proposed'] = len(proposed_specific)
-        info[subcategory_code]['number_of_validations_rejected'] = len(rejected_specific)
-        comparative_report = pd.DataFrame(validations_to_df)
-        if comparative_report.empty:
-            comparative_report = pd.DataFrame(columns=['code', 'expression', 'status', 'subcategory_code', 'is_duplicated'])
-
-        merged = comparative_report.merge(total_external, left_on='code', right_on='ID', how='outer', indicator=True)
-        info[subcategory_code]['matches_codes(generated_expressions)'] = merged[~merged['code'].isna()]["code"].unique().tolist()
-        # external_code, external_expression, proposed action, code, expression, ...
-
-        # if not merged.empty:
-        merged["expression_from_db"] = merged["code"].map(ExternalData.get_expression_from_code)
-        del merged['_merge']
-        errors[subcategory_code]['duplicated_codes'] = list(set(errors[subcategory_code]['duplicated_codes']))
-        info[subcategory_code]["errors"] = errors[subcategory_code]  # TODO
-        proposed_expressions_without_code = proposed_specific[proposed_specific['ID'].isna()]["Formula"].unique().tolist()
-        if proposed_expressions_without_code:
-            info[subcategory_code]['proposed_expressions_without_code'] = proposed_expressions_without_code
-        info[subcategory_code]['aditional info']=[{elto["expression"]:elto["aproximated_operations"]} for elto in validations if not elto["operation_code"]]
-        return merged, info
-
-    # @staticmethod
-    # def create_report(report_df:pd.DataFrame, info_dict:dict, subcategory_code:str=None):
-    #     name_report = subcategory_code if subcategory_code else 'all_subcategories'
-    #     path = Path(__file__).parent / 'utils_report' / 'hierarchies_report'
-    #     path_errors = path / f"{name_report}_info.json"
-    #     path_validations = path / f"{name_report}_validations.csv"
-    #     report_df.to_csv(path_validations, index=False)
-    #     with open(path_errors, 'w') as f:
-    #         f.write(json.dumps(info_dict))
-
-    @classmethod
-    def create_report(cls, report_df:pd.DataFrame, info_dict:dict, subcategory_code:str=None):
-        name_report = subcategory_code if subcategory_code else 'all_subcategories'
-        path = Path(__file__).parent / 'utils_report' / 'hierarchies_report'
-        super().create_report(report_df, info_dict, path, name_report)
-
-
-class ExternalDataSign(ExternalData):
-
-    def __init__(self):
-        super().__init__()
-        self.proposed_rules = self.proposed_rules[self.proposed_rules['Type']=="Sign"]
-        self.rejected_rules = self.rejected_rules[self.rejected_rules['Type']=="Sign"]
-
-
-    def match_code(self, validations: list, report_type: str):
-        """
-        """
-        for elto in validations:
-            total_cells_id = elto["cell_data"]
-            sql_session = get_session()
-            matched_codes = ViewReportTypeOperandReferenceInfo.get_cell_report_operations(sql_session, total_cells_id, report_type)
-            elto["operation_code"] = matched_codes
-            sql_session.close()
-            # new version end
-
-        return validations
-
-    def compare_all_sign_report(self, validations: list):
-        proposed, rejected = self.proposed_rules, self.rejected_rules
-        proposed_specific = pd.DataFrame(columns=['ID', 'Formula', 'ProposedAction', 'Review Action', 'Framework']) if proposed.empty else proposed[['ID', 'Formula', 'ProposedAction', 'Review Action', 'Framework']]
-        rejected_specific = pd.DataFrame(columns=['ID', 'Formula', 'ProposedAction', 'Review Action']) if rejected.empty else rejected[['ID', 'Formula', 'ProposedAction', 'ReviewAction']].rename(columns={'ReviewAction':'Review Action'})
-        info = {}
-        errors = {}
-
-        proposed_codes = proposed_specific[~proposed_specific['ID'].isna()]["ID"].unique().tolist()
-        rejected_codes = rejected_specific['ID'].unique().tolist()
-        total_external = pd.concat([proposed_specific, rejected_specific])
-        total_external_codes = total_external['ID'].unique().tolist()
-        # validations_codes
-        validations_codes = []
-
-        [validations_codes.extend(elto['operation_code']) for elto in validations]
-
-        if len(validations_codes) != len(set(validations_codes)):
-            errors['duplicated_codes'] = list(set([code for code in validations_codes if validations_codes.count(code) > 1]))
-            validations_codes = list(set(validations_codes))
-
-        # no match expressions
-        errors['expressions_dont_match_with_proposed'] = [elto['expression'] for elto in validations if len(elto['operation_code']) == 0]
-        # missing codes
-        errors['missing_codes'] = [code for code in total_external_codes if code not in validations_codes]
-        # exceded codes
-        errors['exceded_codes'] = [code for code in validations_codes if code not in total_external_codes]
-
-        validations_to_df = []
-        for elto in validations:
-            if len(elto['operation_code']) == 0:
-                validations_to_df.append(
-                    {'code':None, 'expression':elto['expression'], 'status':elto['status'],
-                    'table':None
-                    }
-                )
-            elif len(elto['operation_code']) == 1:
-                validations_to_df.append(
-                    {'code':elto['operation_code'][0], 'expression':elto['expression'], 'status':elto['status'],
-                    'table':None
-                    }
-                    )
-            else:
-                for code in elto['operation_code']:
-                    validations_to_df.append(
-                        {'code':code, 'expression':elto['expression'], 'status':elto['status'],
-                        'table':None
-                        }
-                        )
-        comparative_report = pd.DataFrame(validations_to_df)
-        if comparative_report.empty:
-            comparative_report = pd.DataFrame(columns=['code', 'expression', 'status', 'subcategory_code', 'is_duplicated'])
-
-        merged = comparative_report.merge(total_external, left_on='code', right_on='ID', how='outer', indicator=True)
-        merged["expression_from_db"] = merged["code"].map(ExternalData.get_expression_from_code)
-        del merged['_merge']
-        # total_merged, total_info = proposed_specific, rejected_specific
-
-        return merged, errors
-
-    @classmethod
-    def create_report(cls, report_df:pd.DataFrame, info_dict:dict):
-        name_report = 'signes'
-        path = Path(__file__).parent / 'utils_report' / 'signes_report'
-        super().create_report(report_df, info_dict, path, name_report)
-
-class ExternalDataExistence(ExternalData):
-
-    def __init__(self):
-        super().__init__()
-        self.proposed_rules = self.proposed_rules[self.proposed_rules['Type']=="Existence"]
-        self.rejected_rules = self.rejected_rules[self.rejected_rules['Type']=="Existence"]
-
-    def compare_all_existence_report(self, validations: list):
-        pass