hestia-earth-utils 0.16.9__tar.gz → 0.16.11__tar.gz

{hestia_earth_utils-0.16.9/hestia_earth_utils.egg-info → hestia_earth_utils-0.16.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hestia_earth_utils
-Version: 0.16.9
+Version: 0.16.11
 Summary: HESTIA's utils library
 Home-page: https://gitlab.com/hestia-earth/hestia-utils
 Author: HESTIA Team

{hestia_earth_utils-0.16.9 → hestia_earth_utils-0.16.11}/hestia_earth/utils/api.py

@@ -9,9 +9,13 @@ from .request import request_url, api_url, api_access_token
 
 
 def _match_key_value(key: str, value):
-    first_key = key.split('.')[0]
-    query = {'match': {key: value}}
-    return {'nested': {'path': first_key, 'query': query}} if first_key in NESTED_SEARCHABLE_KEYS else query
+    first_key = key.split(".")[0]
+    query = {"match": {key: value}}
+    return (
+        {"nested": {"path": first_key, "query": query}}
+        if first_key in NESTED_SEARCHABLE_KEYS
+        else query
+    )
 
 
 def _retry_request_error(func, retry_max: int = 5):
@@ -30,26 +34,28 @@ def _retry_request_error(func, retry_max: int = 5):
 def _safe_get_request(url: str, res_error=None):
     def exec():
         try:
-            headers = {'Content-Type': 'application/json'}
+            headers = {"Content-Type": "application/json"}
             access_token = api_access_token()
             if access_token:
-                headers['X-Access-Token'] = access_token
+                headers["X-Access-Token"] = access_token
             return requests.get(url, headers=headers).json()
         except requests.exceptions.RequestException:
             return res_error
+
     return _retry_request_error(exec)
 
 
 def _safe_post_request(url: str, body: dict, res_error={}):
     def exec():
         try:
-            headers = {'Content-Type': 'application/json'}
+            headers = {"Content-Type": "application/json"}
             access_token = api_access_token()
             if access_token:
-                headers['X-Access-Token'] = access_token
+                headers["X-Access-Token"] = access_token
             return requests.post(url, json.dumps(body), headers=headers).json()
         except requests.exceptions.RequestException:
             return res_error
+
     return _retry_request_error(exec)
 
 
@@ -63,11 +69,21 @@ def node_type_to_url(node_type: SchemaType):
 
 def node_to_path(node_type: SchemaType, node_id: str, data_state=None):
     jsonld_path = os.path.join(_parse_node_type(node_type), f"{node_id}.jsonld")
-    return jsonld_path if data_state is None or data_state == 'original' or len(data_state) == 0 else \
-        os.path.join(data_state, jsonld_path)
-
-
-def find_related(node_type: SchemaType, id: str, related_type: SchemaType, limit=100, offset=0, relationship=None):
+    return (
+        jsonld_path
+        if data_state is None or data_state == "original" or len(data_state) == 0
+        else os.path.join(data_state, jsonld_path)
+    )
+
+
+def find_related(
+    node_type: SchemaType,
+    id: str,
+    related_type: SchemaType,
+    limit=100,
+    offset=0,
+    relationship=None,
+):
     """
     Return the list of related Nodes by going through a "relationship".
     You can navigate the HESTIA Graph Database using this method.
@@ -88,16 +104,26 @@ def find_related(node_type: SchemaType, id: str, related_type: SchemaType, limit
     relationship
         The relationship used to connect both Node. See the API for more information.
     """
-    url = request_url(f"{api_url()}/{node_type_to_url(node_type)}/{id}/{node_type_to_url(related_type)}",
-                      limit=limit, offset=offset, relationship=relationship)
+    url = request_url(
+        f"{api_url()}/{node_type_to_url(node_type)}/{id}/{node_type_to_url(related_type)}",
+        limit=limit,
+        offset=offset,
+        relationship=relationship,
+    )
     response = _safe_get_request(url)
     # handle errors
-    return response.get('results', []) if isinstance(response, dict) else response
+    return response.get("results", []) if isinstance(response, dict) else response
 
 
-def _exec_download_hestia(node_id: str, node_type=SchemaType.TERM, data_state='', mode='') -> dict:
+def _exec_download_hestia(
+    node_id: str, node_type=SchemaType.TERM, data_state="", mode=""
+) -> dict:
     def fallback():
-        url = request_url(f"{api_url()}/{node_type_to_url(node_type)}/{node_id}", dataState=data_state, mode=mode)
+        url = request_url(
+            f"{api_url()}/{node_type_to_url(node_type)}/{node_id}",
+            dataState=data_state,
+            mode=mode,
+        )
         return _safe_get_request(url)
 
     try:
@@ -111,7 +137,9 @@ def _exec_download_hestia(node_id: str, node_type=SchemaType.TERM, data_state=''
 _exec_download_hestia_cached = cache(_exec_download_hestia)
 
 
-def download_hestia(node_id: str, node_type=SchemaType.TERM, data_state='', mode='') -> dict:
+def download_hestia(
+    node_id: str, node_type=SchemaType.TERM, data_state="", mode=""
+) -> dict:
     """
     Download a Node from the HESTIA Database.
 
@@ -134,7 +162,11 @@ def download_hestia(node_id: str, node_type=SchemaType.TERM, data_state='', mode
         The `JSON` content of the Node.
     """
     # cache all requests to `Term` by default, as the values are not likely to change during a single execution
-    download_func = _exec_download_hestia_cached if _parse_node_type(node_type) == 'Term' else _exec_download_hestia
+    download_func = (
+        _exec_download_hestia_cached
+        if _parse_node_type(node_type) == "Term"
+        else _exec_download_hestia
+    )
     return download_func(node_id, node_type, data_state, mode)
 
 
@@ -154,10 +186,11 @@ def node_exists(node_id: str, node_type=SchemaType.TERM) -> bool:
     bool
         True if the node exists, False otherwise.
     """
+
     def fallback():
         url = request_url(f"{api_url()}/{node_type_to_url(node_type)}/{node_id}")
         result = _safe_get_request(url)
-        return result is not None and '@id' in result
+        return result is not None and "@id" in result
 
     try:
         return _exists(node_to_path(node_type, node_id))
@@ -165,7 +198,9 @@ def node_exists(node_id: str, node_type=SchemaType.TERM) -> bool:
         return fallback()
 
 
-def search(query: dict, fields=['@type', '@id', 'name'], limit=10, offset=0, sort=None) -> list:
+def search(
+    query: dict, fields=["@type", "@id", "name"], limit=10, offset=0, sort=None
+) -> list:
     """
     Executes a raw search on the HESTIA Platform.
 
@@ -189,13 +224,16 @@ def search(query: dict, fields=['@type', '@id', 'name'], limit=10, offset=0, sor
     List[JSON]
         List of Nodes (as JSON) found.
     """
-    return _safe_post_request(f"{api_url()}/search", {
-        'query': query,
-        'limit': limit,
-        'offset': offset,
-        'fields': fields,
-        **({'sort': sort} if sort is not None else {})
-    }).get('results', [])
+    return _safe_post_request(
+        f"{api_url()}/search",
+        {
+            "query": query,
+            "limit": limit,
+            "offset": offset,
+            "fields": fields,
+            **({"sort": sort} if sort is not None else {}),
+        },
+    ).get("results", [])
 
 
 def find_node(node_type: SchemaType, args: dict, limit=10) -> list:
@@ -217,10 +255,12 @@ def find_node(node_type: SchemaType, args: dict, limit=10) -> list:
     List[JSON]
         List of Nodes (as JSON) found.
     """
-    query_args = list(map(lambda key: _match_key_value(key, args.get(key)), args.keys()))
-    must = [{'match': {'@type': node_type.value}}]
+    query_args = list(
+        map(lambda key: _match_key_value(key, args.get(key)), args.keys())
+    )
+    must = [{"match": {"@type": node_type.value}}]
     must.extend(query_args)
-    return search(query={'bool': {'must': must}}, limit=limit)
+    return search(query={"bool": {"must": must}}, limit=limit)
 
 
 def find_node_exact(node_type: SchemaType, args: dict) -> dict:
@@ -240,10 +280,12 @@ def find_node_exact(node_type: SchemaType, args: dict) -> dict:
     JSON
         JSON of the node if found, else `None`.
     """
-    query_args = list(map(lambda key: _match_key_value(f"{key}.keyword", args.get(key)), args.keys()))
-    must = [{'match': {'@type': node_type.value}}]
+    query_args = list(
+        map(lambda key: _match_key_value(f"{key}.keyword", args.get(key)), args.keys())
+    )
+    must = [{"match": {"@type": node_type.value}}]
     must.extend(query_args)
-    results = search(query={'bool': {'must': must}}, limit=2)
+    results = search(query={"bool": {"must": must}}, limit=2)
     # do not return a duplicate
     return results[0] if len(results) == 1 else None
 
@@ -263,7 +305,7 @@ def find_term_ids_by_names(names, batch_size=1000):
                         "must": [
                             {
                                 "terms": {
-                                    "name.keyword": unique_names[i: i + batch_size],
+                                    "name.keyword": unique_names[i : i + batch_size],
                                 }
                             },
                             {"term": {"@type.keyword": "Term"}},
@@ -274,7 +316,7 @@ def find_term_ids_by_names(names, batch_size=1000):
         }
         results = search(query=query, limit=batch_size, fields=["@id", "name"])
         for term in results:
-            result[term.get('name')] = term.get('@id')
+            result[term.get("name")] = term.get("@id")
     missing_names = unique_names_set - set(result.keys())
     if len(missing_names):
         raise Exception(f"Failed to find ids for names: {'; '.join(missing_names)}")

{hestia_earth_utils-0.16.9 → hestia_earth_utils-0.16.11}/hestia_earth/utils/blank_node.py

@@ -12,26 +12,31 @@ from .model import filter_list_term_type
 
 
 def get_lookup_value(blank_node: dict, column: str):
-    term = blank_node.get('term', {})
+    term = blank_node.get("term", {})
     table_name = f"{term.get('termType')}.csv" if term else None
-    value = get_table_value(
-        download_lookup(table_name), 'term.id', term.get('@id'), column
-    ) if table_name else None
+    value = (
+        get_table_value(download_lookup(table_name), "term.id", term.get("@id"), column)
+        if table_name
+        else None
+    )
     return value
 
 
-def group_by_keys(values: list, group_keys: list = ['term']):
+def group_by_keys(values: list, group_keys: list = ["term"]):
     def node_value(value):
         return (
-            value.get('@id') if isinstance(value, dict) else
-            list(map(node_value, value)) if isinstance(value, list) else
-            value
+            value.get("@id")
+            if isinstance(value, dict)
+            else list(map(node_value, value)) if isinstance(value, list) else value
         )
 
     def run(group: dict, node: dict):
-        group_key = '-'.join(flatten(non_empty_list([node_value(node.get(v)) for v in group_keys])))
+        group_key = "-".join(
+            flatten(non_empty_list([node_value(node.get(v)) for v in group_keys]))
+        )
         group[group_key] = group.get(group_key, []) + [node]
         return group
+
     return reduce(run, values, {})
 
 
@@ -39,11 +44,12 @@ class ArrayTreatment(Enum):
     """
     Enum representing different treatments for arrays of values.
     """
-    MEAN = 'mean'
-    MODE = 'mode'
-    SUM = 'sum'
-    FIRST = 'first'
-    LAST = 'last'
+
+    MEAN = "mean"
+    MODE = "mode"
+    SUM = "sum"
+    FIRST = "first"
+    LAST = "last"
 
 
 def _should_run_array_treatment(value):
@@ -52,11 +58,21 @@ def _should_run_array_treatment(value):
 
 DEFAULT_ARRAY_TREATMENT = ArrayTreatment.MEAN
 ARRAY_TREATMENT_TO_REDUCER = {
-    ArrayTreatment.MEAN: lambda value: mean(non_empty_list(value)) if _should_run_array_treatment(value) else None,
-    ArrayTreatment.MODE: lambda value: mode(non_empty_list(value)) if _should_run_array_treatment(value) else None,
-    ArrayTreatment.SUM: lambda value: sum(non_empty_list(value)) if _should_run_array_treatment(value) else None,
-    ArrayTreatment.FIRST: lambda value: value[0] if _should_run_array_treatment(value) else None,
-    ArrayTreatment.LAST: lambda value: value[-1] if _should_run_array_treatment(value) else None
+    ArrayTreatment.MEAN: lambda value: (
+        mean(non_empty_list(value)) if _should_run_array_treatment(value) else None
+    ),
+    ArrayTreatment.MODE: lambda value: (
+        mode(non_empty_list(value)) if _should_run_array_treatment(value) else None
+    ),
+    ArrayTreatment.SUM: lambda value: (
+        sum(non_empty_list(value)) if _should_run_array_treatment(value) else None
+    ),
+    ArrayTreatment.FIRST: lambda value: (
+        value[0] if _should_run_array_treatment(value) else None
+    ),
+    ArrayTreatment.LAST: lambda value: (
+        value[-1] if _should_run_array_treatment(value) else None
+    ),
 }
 """
 A dictionary mapping ArrayTreatment enums to corresponding reducer functions.
@@ -66,7 +82,7 @@ A dictionary mapping ArrayTreatment enums to corresponding reducer functions.
 def _retrieve_array_treatment(
     node: dict,
     is_larger_unit: bool = False,
-    default: ArrayTreatment = ArrayTreatment.MEAN
+    default: ArrayTreatment = ArrayTreatment.MEAN,
 ) -> ArrayTreatment:
     """
     Retrieves the array treatment for a given node.
@@ -90,27 +106,26 @@ def _retrieve_array_treatment(
         The retrieved array treatment.
 
     """
-    ARRAY_TREATMENT_LOOKUPS = [
-        'arrayTreatmentLargerUnitOfTime',
-        'arrayTreatment'
-    ]
-    lookup = ARRAY_TREATMENT_LOOKUPS[0] if is_larger_unit else ARRAY_TREATMENT_LOOKUPS[1]
+    ARRAY_TREATMENT_LOOKUPS = ["arrayTreatmentLargerUnitOfTime", "arrayTreatment"]
+    lookup = (
+        ARRAY_TREATMENT_LOOKUPS[0] if is_larger_unit else ARRAY_TREATMENT_LOOKUPS[1]
+    )
 
     lookup_value = get_lookup_value(node, lookup)
 
     return next(
         (treatment for treatment in ArrayTreatment if treatment.value == lookup_value),
-        default
+        default,
     )
 
 
 def get_node_value(
     node: dict,
-    key: str = 'value',
+    key: str = "value",
     is_larger_unit: bool = False,
     array_treatment: Optional[ArrayTreatment] = None,
     default_array_treatment: Optional[ArrayTreatment] = ArrayTreatment.MEAN,
-    default: Any = 0
+    default: Any = 0,
 ) -> Union[float, bool]:
     """
     Get the value from the dictionary representing the node,
@@ -136,26 +151,44 @@ def get_node_value(
     float | bool
         The extracted value from the node.
     """
-    value = node.get(key)
-
-    reducer = ARRAY_TREATMENT_TO_REDUCER[(
-        array_treatment or
-        _retrieve_array_treatment(node, is_larger_unit=is_larger_unit, default=default_array_treatment)
-    )] if isinstance(value, list) and len(value) > 0 else None
+    value = (node or {}).get(key)
+
+    reducer = (
+        ARRAY_TREATMENT_TO_REDUCER[
+            (
+                array_treatment
+                or _retrieve_array_treatment(
+                    node, is_larger_unit=is_larger_unit, default=default_array_treatment
+                )
+            )
+        ]
+        if isinstance(value, list) and len(value) > 0
+        else None
+    )
 
-    return reducer(value) if reducer else (
-        value if any([isinstance(value, float), isinstance(value, int), isinstance(value, bool)]) else
-        default if not non_empty_value(value) else
-        value
+    return (
+        reducer(value)
+        if reducer
+        else (
+            value
+            if any(
+                [
+                    isinstance(value, float),
+                    isinstance(value, int),
+                    isinstance(value, bool),
+                ]
+            )
+            else default if not non_empty_value(value) else value
+        )
     )
 
 
-_BLANK_NODE_GROUPING_KEYS = {
-    TermTermType.EMISSION: ['methodModel']
-}
+_BLANK_NODE_GROUPING_KEYS = {TermTermType.EMISSION: ["methodModel"]}
 
 
-def get_blank_nodes_calculation_status(node: dict, list_key: str, termType: TermTermType):
+def get_blank_nodes_calculation_status(
+    node: dict, list_key: str, termType: TermTermType
+):
     """
     Get calculation status for a Node and a list of Blank node.
     Example: get the calculation status for all emissions included in the HESTIA system boundary.
@@ -178,31 +211,38 @@ def get_blank_nodes_calculation_status(node: dict, list_key: str, termType: Term
     """
     all_term_ids = cycle_emissions_in_system_boundary(node, termType=termType)
     blank_nodes = filter_list_term_type(node.get(list_key, []), termType)
-    blank_nodes_by_term = group_by_keys(blank_nodes, ['term'])
+    blank_nodes_by_term = group_by_keys(blank_nodes, ["term"])
     blank_nodes_grouping_keys = _BLANK_NODE_GROUPING_KEYS.get(termType) or []
 
     def blank_node_data(blank_nodes: list):
-        value = get_node_value({
-            'term': blank_nodes[0].get('term'),
-            'value': list(map(get_node_value, blank_nodes))
-        })
-        inputs = flatten(map(lambda v: v.get('inputs', []), blank_nodes))
-        return {
-            'value': value
-        } | ({
-            'inputs': sorted(list(map(lambda v: v.get('@id'), inputs)))
-        } if inputs else {})
+        value = get_node_value(
+            {
+                "term": blank_nodes[0].get("term"),
+                "value": list(map(get_node_value, blank_nodes)),
+            }
+        )
+        inputs = flatten(map(lambda v: v.get("inputs", []), blank_nodes))
+        return {"value": value} | (
+            {"inputs": sorted(list(map(lambda v: v.get("@id"), inputs)))}
+            if inputs
+            else {}
+        )
 
     def map_blank_node(term_id: str):
         values = blank_nodes_by_term.get(term_id, [])
-        grouped_blank_nodes = group_by_keys(values, blank_nodes_grouping_keys) if blank_nodes_grouping_keys else {}
+        grouped_blank_nodes = (
+            group_by_keys(values, blank_nodes_grouping_keys)
+            if blank_nodes_grouping_keys
+            else {}
+        )
         return (
-            {} if not values else
-            {
-                k: blank_node_data(v)
-                for k, v in grouped_blank_nodes.items()
-            } if grouped_blank_nodes else
-            blank_node_data([values[0]])
+            {}
+            if not values
+            else (
+                {k: blank_node_data(v) for k, v in grouped_blank_nodes.items()}
+                if grouped_blank_nodes
+                else blank_node_data([values[0]])
+            )
         )
 
     return {term_id: map_blank_node(term_id) for term_id in all_term_ids}

hestia_earth_utils-0.16.11/hestia_earth/utils/calculation_status.py

@@ -0,0 +1,75 @@
+import pandas as pd
+
+from .cycle import get_cycle_emissions_calculation_status
+
+
+def _emissions_color(row):
+    color = (
+        "red"
+        if row["emissions-missing"] > 0
+        else "yellow" if row["emissions-incomplete"] > 0 else "lightgreen"
+    )
+    return [f"background-color: {color}"] * len(row)
+
+
+def _emissions_with_status(cycle: dict):
+    emissions = get_cycle_emissions_calculation_status(cycle)
+    all_emissions = emissions.keys()
+    # an emission is missing if there is no value (ignore `missingInputs`)
+    missing_emissions = set(
+        [
+            k
+            for k, v in emissions.items()
+            if len((set(v.keys()) - set(["missingInputs"]))) == 0
+        ]
+    )
+    # an emission is incomplete if it has missing inputs
+    incomplete_emissions = set(
+        [
+            k
+            for k, v in emissions.items()
+            if all([len(v.get("missingInputs", [])) > 0, k not in missing_emissions])
+        ]
+    )
+    complete_emissions = set(
+        [
+            k
+            for k, v in emissions.items()
+            if all(
+                [
+                    len(v.get("missingInputs", [])) == 0,
+                    len((set(v.keys()) - set(["missingInputs"]))) > 0,
+                ]
+            )
+        ]
+    )
+    return {
+        "emissions-total": len(all_emissions),
+        "emissions-complete": len(complete_emissions),
+        "emissions-incomplete": len(incomplete_emissions),
+        "emissions-missing": len(missing_emissions),
+        "emissions": emissions,
+    }
+
+
+def _handle_lists(df: pd.DataFrame, columns: list):
+    for col in columns:
+        df[col] = df[col].apply(lambda v: ";".join(v) if isinstance(v, list) else v)
+    return df
+
+
+def get_nodes_calculations_status_dataframe(nodes: list, file_format: str = "excel"):
+    cycles_status = [
+        {"id": cycle.get("@id") or cycle.get("id")} | _emissions_with_status(cycle)
+        for cycle in nodes
+        if (cycle.get("@type") or cycle.get("type")) == "Cycle"
+    ]
+    df = pd.json_normalize(cycles_status, errors="ignore")
+    # convert list of inputs to semi-column strings
+    list_columns = [
+        col
+        for col in df.columns
+        if col.endswith(".inputs") or col.endswith(".missingInputs")
+    ]
+    df = _handle_lists(df, list_columns)
+    return df.style.apply(_emissions_color, axis=1) if file_format == "excel" else df

{hestia_earth_utils-0.16.9 → hestia_earth_utils-0.16.11}/hestia_earth/utils/cycle.py

@@ -5,11 +5,9 @@ from .blank_node import get_blank_nodes_calculation_status
 
 
 def _extend_missing_inputs(value: dict, input_ids: set):
-    included_inputs = set(flatten([
-        v.get('inputs', []) for v in value.values()
-    ]))
+    included_inputs = set(flatten([v.get("inputs", []) for v in value.values()]))
     missing_inputs = input_ids - included_inputs
-    return {'missingInputs': sorted(list(missing_inputs))} if missing_inputs else {}
+    return {"missingInputs": sorted(list(missing_inputs))} if missing_inputs else {}
 
 
 def get_cycle_emissions_calculation_status(cycle: dict):
@@ -28,9 +26,11 @@ def get_cycle_emissions_calculation_status(cycle: dict):
         and the resulting calculation as value, containing the recalculated `value`, `method` and `methodTier`.
         Note: if a calculation fails for an emission, the `value` is an empty dictionary.
     """
-    status = get_blank_nodes_calculation_status(cycle, 'emissions', TermTermType.EMISSION)
-    input_ids = set([v.get('term', {}).get('@id') for v in cycle.get('inputs', [])])
+    status = get_blank_nodes_calculation_status(
+        cycle, "emissions", TermTermType.EMISSION
+    )
+    input_ids = set([v.get("term", {}).get("@id") for v in cycle.get("inputs", [])])
     return {
-        k: v | (_extend_missing_inputs(v, input_ids) if 'InputsProduction' in k else {})
+        k: v | (_extend_missing_inputs(v, input_ids) if "InputsProduction" in k else {})
         for k, v in status.items()
     }

{hestia_earth_utils-0.16.9 → hestia_earth_utils-0.16.11}/hestia_earth/utils/date.py

@@ -61,7 +61,10 @@ def is_in_days(date: str) -> bool:
     bool
         True if the date contains the year, month and day.
     """
-    return date is not None and re.compile(r'^[\d]{4}\-[\d]{2}\-[\d]{2}').match(date) is not None
+    return (
+        date is not None
+        and re.compile(r"^[\d]{4}\-[\d]{2}\-[\d]{2}").match(date) is not None
+    )
 
 
 def is_in_months(date: str) -> bool:
@@ -78,4 +81,6 @@ def is_in_months(date: str) -> bool:
     bool
         True if the date contains the year, month but no day.
     """
-    return date is not None and re.compile(r'^[\d]{4}\-[\d]{2}$').match(date) is not None
+    return (
+        date is not None and re.compile(r"^[\d]{4}\-[\d]{2}$").match(date) is not None
+    )

{hestia_earth_utils-0.16.9 → hestia_earth_utils-0.16.11}/hestia_earth/utils/descriptive_stats.py

@@ -9,7 +9,7 @@ def calc_descriptive_stats(
     arr: NDArray,
     stats_definition: Union[Enum, str],
     axis: Optional[int] = None,
-    decimals: int = 6
+    decimals: int = 6,
 ) -> dict:
     """
     Calculate the descriptive stats for an array row-wise, round them to specified number of decimal places and return
@@ -34,9 +34,9 @@ def calc_descriptive_stats(
     max_ = around(arr.max(axis=axis), decimals)
 
     observations = (
-        [arr.shape[0]] * arr.shape[1] if axis == 0
-        else [arr.shape[1]] * arr.shape[0] if axis == 1
-        else [arr.size]
+        [arr.shape[0]] * arr.shape[1]
+        if axis == 0
+        else [arr.shape[1]] * arr.shape[0] if axis == 1 else [arr.size]
     )
 
     return {
@@ -44,6 +44,10 @@ def calc_descriptive_stats(
         "sd": list(sd) if isinstance(sd, Iterable) else [sd],
         "min": list(min_) if isinstance(min_, Iterable) else [min_],
         "max": list(max_) if isinstance(max_, Iterable) else [max_],
-        "statsDefinition": stats_definition.value if isinstance(stats_definition, Enum) else stats_definition,
-        "observations": observations
+        "statsDefinition": (
+            stats_definition.value
+            if isinstance(stats_definition, Enum)
+            else stats_definition
+        ),
+        "observations": observations,
     }