eea.plotly 1.6__tar.gz → 1.8__tar.gz

{eea_plotly-1.6/eea.plotly.egg-info → eea_plotly-1.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: eea.plotly
-Version: 1.6
+Version: 1.8
 Summary: volto-plotlycharts backend support
 Home-page: https://github.com/eea/eea.plotly
 Author: European Environment Agency: IDM2 A-Team
@@ -145,6 +145,16 @@ EEA_ - European Environment Agency (EU)
 Changelog
 =========
 
+1.8 - (2025-08-20)
+---------------------------
+* Change: fix 'no data provided' soer indicator
+  [razvanMiu]
+
+1.7 - (2025-07-06)
+---------------------------
+* Change: soer_miniature improved logic
+  [razvanMiu]
+
 1.6 - (2025-06-24)
 ---------------------------
 * Change: pin kaleido version to 0.2.1

{eea_plotly-1.6 → eea_plotly-1.8}/docs/HISTORY.txt

@@ -1,6 +1,16 @@
 Changelog
 =========
 
+1.8 - (2025-08-20)
+---------------------------
+* Change: fix 'no data provided' soer indicator
+  [razvanMiu]
+
+1.7 - (2025-07-06)
+---------------------------
+* Change: soer_miniature improved logic
+  [razvanMiu]
+
 1.6 - (2025-06-24)
 ---------------------------
 * Change: pin kaleido version to 0.2.1

{eea_plotly-1.6 → eea_plotly-1.8}/eea/plotly/browser/preview_adapter/soer_miniature.py

@@ -1,6 +1,8 @@
 """ SOER miniature theme for Plotly visualizations. """
 import math
 
+SOER_TRACES_COUNT = 5
+
 
 def nice_step(vmin, vmax, target_ticks=5):
     """Calculate a 'nice' step size for axis ticks, similar to Plotly/D3."""
@@ -12,7 +14,6 @@ def nice_step(vmin, vmax, target_ticks=5):
     magnitude = 10 ** math.floor(math.log10(raw_step))
     residual = raw_step / magnitude
 
-    # D3/Plotly uses [1, 2, 2.5, 5, 10]
     if residual <= 1:
         nice_multiplier = 1
     elif residual <= 2:
@@ -34,14 +35,22 @@ def exact_step(vmin, vmax, target_ticks=5):
     return abs(vmax - vmin) / (target_ticks - 1)
 
 
+def toFloat(v):
+    """ Convert value to float """
+    try:
+        return float(v)
+    except ValueError:
+        return 0
+
+
 def getMin(arr):
     """ Get minimum value from array """
-    return min(float(v) for v in arr if v is not None)
+    return min(toFloat(v) for v in arr if v is not None)
 
 
 def getMax(arr):
     """ Get maximum value from array """
-    return max(float(v) for v in arr if v is not None)
+    return max(toFloat(v) for v in arr if v is not None)
 
 
 def serialize(context):
@@ -51,50 +60,107 @@ def serialize(context):
 
     data = context.visualization["data"]
     layout = context.visualization["layout"]
-    min_year = float("inf")
-    max_year = float("-inf")
-    first_val = None
-    new_x = []
-    new_y = []
 
-    if len(data) < 5:
+    top = (
+        layout.get("margin", {}).get("t") or
+        layout.get("template", {}).get("margin", {}).get("t")
+    ) or 0
+    nticks = max(int((context.height - top) / 100), 2)
+
+    if len(data) < SOER_TRACES_COUNT:
         layout["xaxis"]["showticklabels"] = False
+        layout["xaxis"]["showgrid"] = False
+        layout["xaxis"]["autorange"] = False
+        layout["xaxis"]["range"] = [0, 1]
+        layout["xaxis"]["tickmode"] = "auto"
+        layout["xaxis"]["gridwidth"] = 4
+
+        layout["yaxis"]["showticklabels"] = False
+        layout["yaxis"]["showgrid"] = True
+        layout["yaxis"]["autorange"] = False
+        layout["yaxis"]["range"] = [0, nticks]
+        layout["yaxis"]["tickmode"] = "linear"
+        layout["yaxis"]["automargin"] = True
+        layout["yaxis"]["gridwidth"] = 4
+
+        del layout["template"]["layout"]["annotationdefaults"]
+        del layout["template"]["layout"]["yaxis"]["rangemode"]
+
+        layout["template"]["layout"]["annotationdefaults"] = {
+            "showarrow": False,
+            "xref": "paper",
+            "yref": "paper"
+        }
         return False
 
-    if "y" in data[0] and "x" in data[0]:
+    min_year = toFloat("inf")
+    max_year = toFloat("-inf")
+    first_val = None
+    new_x = []
+    new_y = []
+    new_text = []
+    dotted_trace = None
+
+    # Custom dotted trace
+    trace_6 = None
+    if len(data) > 5:
+        trace_6 = data[5]
+
+    if trace_6 and trace_6.get("id") == "country_trend_dotted":
+        trace_6["mode"] = "lines"
+        dotted_trace = trace_6
+    elif trace_6:
+        trace_6["visible"] = False
+        trace_6["x"] = None
+        trace_6["y"] = None
+
+    if data[0].get("x") is not None and data[0].get("y") is not None:
+        x_len = len(data[0].get("x") or [])
+        y_len = len(data[0].get("y") or [])
+        text_len = len(data[0].get("text") or [])
+
+        if y_len < x_len:
+            data[0]["y"] = data[0]["y"] + [None] * (x_len - y_len)
+
         for index, val in enumerate(data[0]["y"]):
             if val and not first_val:
                 first_val = val
             if not first_val:
                 continue
-            year = data[0]["x"][index]
+            year = toFloat(data[0]["x"][index]) if index < x_len else None
+            text = data[0]["text"][index] if index < text_len else None
             new_x.append(year)
             new_y.append(val)
+            new_text.append(text)
             if val and year > max_year:
                 max_year = year
             if val and year < min_year:
                 min_year = year
 
-        text_len = len(data[0]["text"])
+        if dotted_trace:
+            first_year = toFloat(dotted_trace["x"][0])
+            if first_year < min_year:
+                min_year = first_year
+
         data[0]["x"] = new_x
         data[0]["y"] = new_y
-        data[0]["text"] = data[0]["text"][text_len - len(new_y):text_len + 1]
+        data[0]["text"] = new_text
+        y_len = len(data[0]["y"])
+        y4_len = len(data[4].get("y") or [])
 
-        if data[4].get("x") and data[4].get("y"):
-            y_len = len(data[0]["y"])
-            y4_len = len(data[4]["y"])
+        if y4_len >= y_len:
             data[4]["x"] = new_x
             data[4]["y"] = data[4]["y"][y4_len - y_len:y4_len + 1]
-        else:
+        elif data[4].get("x") is None or data[4].get("y") is None:
             data[4] = {
                 "type": "scatter",
                 "x": new_x,
                 "y": [None] * len(new_y),
                 "visible": True,
                 "marker": {
-                    "color": "rgba(0, 0, 0, 0)",
+                    "color": "rgba(0, 0, 0, 1)",
                     "line": {
-                        "color": "rgba(0, 0, 0, 0)"
+                        "color": "rgba(0, 0, 0, 1)"
                     }
                 }
             }
@@ -103,25 +169,23 @@ def serialize(context):
         layout["xaxis"]["tickmode"] = "array"
         layout["xaxis"]["tickvals"] = [min_year, max_year, 2030]
         layout["xaxis"]["range"] = [
-            min_year - 1, 2032]
+            min_year - 2, 2032]
         layout["xaxis"]["autorange"] = True
 
     y_values = (
         (data[0].get("y") or []) +
         (data[1].get("y") or []) +
-        (data[4].get("y") or [])
+        (data[4].get("y") or []) +
+        ((trace_6.get("y") or []) if trace_6 else [])
     )
 
     if y_values:
-        top = layout["margin"]["t"] or layout["template"]["margin"]["t"]
         min_y = getMin(y_values)
         max_y = getMax(y_values)
 
         min_y = min_y if min_y < 0 else 0
         max_y = max_y if max_y > 0 else 0
 
-        nticks = max(int((context.height - top) / 100), 2)
-
         step = exact_step(min_y, max_y, nticks)
 
         layout["yaxis"]["tickmode"] = "linear"