des codes erreurs lors du calcul des indicateurs

Author: Léonard Michelet

enthic/ontology.py

@@ -3158,3 +3158,23 @@ def read_account():
         "function": "compute_data_availability",
     },
 }
+
+SCORE_ERROR = {
+    -1000: "Montant des salaires incohérent",
+    -1100: "Montant des salaires non fournis",
+    -1200: "Montant des salaires à zéro",
+    -1300: "Montant des salaires négatif",
+    -2000: "Montant des cotisations sociales incohérent",
+    -2100: "Montant des cotisations sociales non fournis",
+    -2200: "Montant des cotisations sociales à zéro",
+    -2300: "Montant des cotisations sociales négatif",
+    -3100: "Montant des impôts sur les bénéfices non fournis",
+    -3200: "Montant des impôts sur les bénéfices négatif",
+    -4100: "Effectifs non fournis",
+    -4200: "Effectifs à zéro",
+    -4300: "Effectifs négatif",
+    -5100: "Bénéfice attribué non négligeable",
+    -6100: "Montant des charges d’exploitation non fournis",
+    -6200: "Montant des charges d’exploitation à zéro",
+    -6300: "Montant des charges d’exploitation négatif",
+}

enthic/scoring/compute_stats.py

@@ -38,6 +38,11 @@ def recursive_fill_tree(tree_item, raw_data):
             break
 
 
+# Accepted amount of difference when checking parent value against it's children
+relative_error = 0.008
+absolute_error = 10
+
+
 def check_tree_data(tree_item):
     """
     Check and complete data in the given tree_item
@@ -68,10 +73,6 @@ def check_tree_data(tree_item):
     for child_name in tree_item["children"]:
         check_tree_data(tree_item["children"][child_name])
 
-    # Accepted amount of difference when checking parent value against it's children
-    relative_error = 0.005
-    absolute_error = 10
-
     # Compute ourself tree_item's value from its children
     computed_sum = 0  # Result from official children's value
     computed_sum_from_computed = 0  # Result from computed children's value
@@ -122,14 +123,15 @@ def check_tree_data(tree_item):
                         child_data["value"] = 0
 
             computed_sum = computed_sum_from_computed
-        # If there is only on value missing from children, set this child's value equal to the computed difference
+        # If there is only one value missing from children, set this child's value equal to the computed difference
         elif child_missing_count == 1:
             for child_name in tree_item["children"]:
                 child_data = tree_item["children"][child_name]["data"]
                 if math.isnan(child_data["value"]):
-                    child_data["computedValue"] = (value - computed_sum) / child["sign"]
-                    child_data["value"] = child_data["computedValue"]
-                    child_data["status"] = "computed"
+                    doubleCheckComputedValueWithChildren(
+                        tree_item["children"][child_name],
+                        (value - computed_sum) / child["sign"],
+                    )
                     tree_item["data"]["status"] = "checked"
                     break
 
@@ -139,6 +141,7 @@ def check_tree_data(tree_item):
             or abs(computed_sum_without_sign - value) < absolute_error
         ):
             tree_item["data"]["status"] = "checked"
+            tree_item["data"]["computedValue"] = computed_sum_without_sign
             # Fix children sign and/or set to zero missing values if any
             for child_name in tree_item["children"]:
                 flip_sign(tree_item["children"][child_name])
@@ -148,10 +151,42 @@ def check_tree_data(tree_item):
         else:
             tree_item["data"]["status"] = "error"
 
-    if computed_sum != tree_item["data"]["value"]:
+    if (
+        computed_sum != tree_item["data"]["value"]
+        and "computedValue" not in tree_item["data"]
+    ):
         tree_item["data"]["computedValue"] = computed_sum_from_computed
 
 
+def computeChildrenSum(item):
+    computedSum = 0
+    for childName in item["children"]:
+        child = item["children"][childName]
+        if "value" in child["data"]:
+            computedSum += child["data"]["value"] * child["sign"]
+    return computedSum
+
+
+def areOpposite(value, reference):
+    """
+    Check if given value is equal to minus reference
+    """
+    result = value + reference
+    if abs(result / reference) < relative_error or abs(result) < absolute_error:
+        return True
+    return False
+
+
+def doubleCheckComputedValueWithChildren(item, computedValue):
+    item["data"]["value"] = computedValue
+    item["data"]["status"] = "computed"
+    if "children" in item:
+        computedSum = computeChildrenSum(item)
+        if areOpposite(computedSum, item["data"]["value"]):
+            item["data"]["value"] = -item["data"]["value"]
+            flip_sign(item)
+
+
 def set_to_zero_computed(tree_item):
     """
     set value of given item and it's children to zero when it hasn't another value
@@ -178,12 +213,23 @@ def flip_sign(item):
     if item["sign"] == -1:
         item["data"]["value"] = -item["data"]["value"]
         item["data"]["status"] = "signFlipped"
+        if "children" in item:
+            computedSum = computeChildrenSum(item)
+            if not areOpposite(computedSum, item["data"]["value"]):
+                return
+            for child_name in item["children"]:
+                child = item["children"][child_name]
+                child["data"]["value"] = -child["data"]["value"]
+                child["data"]["status"] = "signFlipped"
 
 
 def gather_data_to_compute(tree, raw):
     root = tree["children"]
     resultat_avant_impot = root["ResultatAvantImpot"]["children"]
     result = {
+        "benefice_attribue": resultat_avant_impot["BenefAttribueOuPerteTransferee"][
+            "data"
+        ]["value"],
         "participation": root["ParticipationSalariesAuxResultats"]["data"]["value"],
         "impot": root["ImpotsSurLesBenefices"]["data"]["value"],
         "resultat_exceptionnel": root["ResultatExceptionnel"]["data"]["value"],

enthic/scoring/scoring_functions.py

@@ -14,8 +14,12 @@ def compute_exploitation_share(data):
     resultat_exploitation = data["resultat_exploitation"]
 
     # If any values unknown, cannot compute score
+    if isnan(impot):
+        return -3100
+    if impot < 0:
+        return -3200
     if (
-        any(isnan(value) for value in [impot, resultat_exploitation])
+        any(isnan(value) for value in [resultat_exploitation])
         or resultat_exploitation < 0
     ):
         return float("nan")
@@ -41,19 +45,24 @@ def compute_overall_wages_weight(data):
     salaires = data["salaires"]
     charges = data["charges"]
 
-    if (
-        isnan(charges)
-        or charges == 0
-        or (isnan(salaires) and isnan(cotisations_sociales))
-    ):
+    if isnan(charges):
+        return -6100
+    if charges == 0:
+        return -6200
+    if isnan(salaires) and isnan(cotisations_sociales):
         return float("nan")
 
     if isnan(salaires):
         salaires = 0
     elif isnan(cotisations_sociales):
         cotisations_sociales = 0
 
-    return (salaires + cotisations_sociales) / charges
+    result = (salaires + cotisations_sociales) / charges
+
+    if result < 0 and charges < 0:
+        return -6300
+
+    return result
 
 
 def compute_wage_quality(data):
@@ -66,15 +75,28 @@ def compute_wage_quality(data):
     cotisations_sociales = data["cotisations_sociales"]
     salaires = data["salaires"]
 
-    if (
-        isnan(salaires)
-        or salaires == 0
-        or isnan(cotisations_sociales)
-        or cotisations_sociales == 0
-    ):
-        return float("nan")
-
-    return cotisations_sociales / salaires
+    if isnan(salaires):
+        return -1100
+    elif isnan(cotisations_sociales):
+        return -2100
+    elif salaires == 0:
+        return -1200
+    elif cotisations_sociales == 0:
+        return -2200
+
+    ratio = cotisations_sociales / salaires
+    if ratio > 1000:
+        if cotisations_sociales < data["charges_exploitation"]:
+            ratio = -1000
+        if cotisations_sociales > data["charges_exploitation"]:
+            ratio = -2000
+
+    if ratio < 0:
+        if salaires < 0:
+            return -1300
+        if cotisations_sociales < 0:
+            return -2300
+    return ratio
 
 
 def compute_average_wage(data):
@@ -87,8 +109,16 @@ def compute_average_wage(data):
     salaires = data["salaires"]
     effectifs = data["effectifs"]
 
-    if isnan(effectifs) or effectifs == 0 or isnan(salaires):
-        return float("nan")
+    if isnan(effectifs):
+        return -4100
+    if effectifs == 0:
+        return -4200
+    if effectifs < 0:
+        return -4300
+    if isnan(salaires):
+        return -1100
+    if salaires < 0:
+        return -1300
 
     return salaires / effectifs
 
@@ -105,27 +135,34 @@ def compute_profit_sharing(data):
     resultat_exceptionnel = data["resultat_exceptionnel"]
     resultat_financier = data["resultat_financier"]
     resultat_exploitation = data["resultat_exploitation"]
+    benefice_attribue = data["benefice_attribue"]
 
+    if isnan(impot):
+        return -3100
+    if impot < 0:
+        return -3200
     if any(
         isnan(value)
         for value in [
-            impot,
             resultat_financier,
             resultat_exceptionnel,
             resultat_exploitation,
         ]
     ):
         return float("nan")
 
-    if (resultat_financier + resultat_exploitation + resultat_exceptionnel) == 0:
+    somme_resultats = resultat_financier + resultat_exploitation + resultat_exceptionnel
+    if somme_resultats == 0:
         return float("nan")
 
     if isnan(participation):
         participation = 0
 
-    return (participation + impot) / (
-        resultat_financier + resultat_exploitation + resultat_exceptionnel
-    )
+    result = (participation + impot) / somme_resultats
+    if result < 0 and not isnan(benefice_attribue) and benefice_attribue > 0:
+        return -5100
+
+    return result
 
 
 def compute_exploitation_part(data):
@@ -159,14 +196,18 @@ def compute_exploitation_part(data):
     ) == 0:
         return float("nan")
 
-    return (data["produits_exploitation"] + data["charges_exploitation"]) / (
+    result = (data["produits_exploitation"] + data["charges_exploitation"]) / (
         data["produits_exploitation"]
         + data["charges_exploitation"]
         + data["produits_exceptionnel"]
         + data["charges_exceptionnel"]
         + data["produits_financier"]
         + data["charges_financier"]
     )
+    if result < 0:
+        if data["charges_exploitation"] < 0:
+            return -6300
+    return result
 
 
 def compute_data_availability(data):

references/naf_transition.json

@@ -22,6 +22,7 @@
   "07.41G": "70.22Z",
   "07.22Z": "62.01Z",
   "05.24L": "47.54Z",
+  "05.701": "46.61Z",
   "00.12A": "01.41Z",
   "01.75G": "13.96Z",
   "05.15L": "46.75Z",

requirements/base.txt

@@ -13,3 +13,4 @@ lxml
 python-dotenv
 pandas
 requests
+pyarrow