d3blocks 2.3.0__tar.gz → 2.3.1__tar.gz

{d3blocks-2.3.0/d3blocks.egg-info → d3blocks-2.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: d3blocks
-Version: 2.3.0
+Version: 2.3.1
 Summary: Python package d3blocks.
 Author-email: Erdogan Taskesen <erdogant@gmail.com>
 License-Expression: GPL-3.0-or-later

{d3blocks-2.3.0 → d3blocks-2.3.1}/d3blocks/__init__.py

@@ -10,7 +10,7 @@ from d3blocks.utils import (
 
 __author__ = 'Erdogan Taskesen'
 __email__ = 'erdogant@gmail.com'
-__version__ = '2.3.0'
+__version__ = '2.3.1'
 
 # Setup root logger
 import logging

{d3blocks-2.3.0 → d3blocks-2.3.1}/d3blocks/d3blocks.py

@@ -1386,7 +1386,7 @@ class D3Blocks():
                       opacity: float = 0.6,
                       stroke: str = '#000000',
                       cmap: str = 'Set1',
-                      color_method: str = 'state',
+                      color_method: str = 'auto',
                       dt_format: str = '%d-%m-%Y %H:%M:%S',
                       damper: float = 1,
                       fontsize: int = 14,
@@ -1440,12 +1440,14 @@ class D3Blocks():
                 * [4, 10, 5, ...]: array-like of the same length as ``df``, aligned positionally with its rows (same convention as ``d3.scatter``'s ``size``).
                 * {'0': 4, '1': 10, '2': 5, ..}: dict keyed by sample_id value.
 
-        color : int, list/array/Series, or dictionary. (default: '#808080') or {sample_id i: hex-color}
+        color : str, list/array/Series, or dictionary. (default: None)
             Color the nodes.
                 * '#000FFF': set all nodes to this color.
-                * ['#808080', '#FFF000', ...]: array-like of the same length as ``df``, aligned positionally with its rows.
-                * {'0': '#808080', '1': '#FFF000', '3': '#000000', ..}: dict keyed by sample_id value.
-                * None: Colors are based on sample_id using the cmap.
+                * ['#808080', '#FFF000', ...]: array-like hex colors of the same length as ``df``, aligned positionally with its rows.
+                * ['Netherlands', 'Germany', ...]: array-like category labels of the same length as ``df``; labels are mapped to colors using ``cmap``.
+                * {'0': '#808080', '1': '#FFF000', '3': '#000000', ..}: dict keyed by sample_id value with hex colors.
+                * {'0': 'NL', '1': 'DE', ..}: dict keyed by sample_id value with category labels; labels are mapped to colors using ``cmap``.
+                * None: Colors are based on sample_id using ``cmap``.
         opacity : float, list/array/Series, or dictionary, (default: 0.6)
             Opacity of the bubbles [0-1].
                 * 0.6: set all nodes to this opacity.
@@ -1458,9 +1460,10 @@ class D3Blocks():
                 * {'0': '#000000', '1': '#ffffff', ..}: dict keyed by sample_id value.
 
         color_method : str
-            Coloring of the nodes.
-                * 'state': Use the colors defined per state as (d3.node_properties).
-                * 'node': Use the colors defined in the dataframe (d3.edge_properties).
+            Coloring mode of the nodes.
+                * 'auto' (default): if ``color`` is provided, use node colors ('node'); otherwise use state colors ('state').
+                * 'state': Use the colors defined per state (``d3.node_properties``), so bubble colors change with activity/state.
+                * 'node': Use the colors defined on nodes (from ``color`` / ``d3.edge_properties``), so each sample keeps its assigned color.
         dt_format : str
             Date time format.
                 * '%d-%m-%Y %H:%M:%S'.
@@ -1634,7 +1637,7 @@ class D3Blocks():
         # Store chart
         self.chart = set_chart_func('Movingbubbles', logger)
         # Store properties
-        self.config = self.chart.set_config(config=self.config, filepath=filepath, title=title, showfig=showfig, overwrite=overwrite, figsize=figsize, timedelta=timedelta, speed=speed, damper=damper, note=note, time_notes=time_notes, fontsize=fontsize, standardize=standardize, center=center, datetime=datetime, sample_id=sample_id, state=state, reset_properties=reset_properties, cmap=cmap, dt_format=dt_format, notebook=notebook, color_method=color_method, save_button=save_button, show_side_panel=show_side_panel, show_top_panel=show_top_panel, dark_mode=dark_mode, color_background=color_background, node_text_inside=node_text_inside, opacity=opacity, stroke=stroke, logger=logger)
+        self.config = self.chart.set_config(config=self.config, filepath=filepath, title=title, showfig=showfig, overwrite=overwrite, figsize=figsize, timedelta=timedelta, speed=speed, damper=damper, note=note, time_notes=time_notes, fontsize=fontsize, standardize=standardize, center=center, datetime=datetime, sample_id=sample_id, state=state, reset_properties=reset_properties, cmap=cmap, dt_format=dt_format, notebook=notebook, color_method=color_method, color=color, save_button=save_button, show_side_panel=show_side_panel, show_top_panel=show_top_panel, dark_mode=dark_mode, color_background=color_background, node_text_inside=node_text_inside, opacity=opacity, stroke=stroke, logger=logger)
         # Set node properties
         if self.config['reset_properties'] or (not hasattr(self, 'node_properties')):
             self.set_node_properties(df[self.config['state']].values, center=self.config['center'], cmap=self.config['cmap'], logger=logger)

{d3blocks-2.3.0 → d3blocks-2.3.1}/d3blocks/movingbubbles/Movingbubbles.py

@@ -24,6 +24,25 @@ except:
     from utils import convert_dataframe_dict, set_path, pre_processing, update_config, write_html_file, include_save_to_svg_script, set_logo, resolve_color_background
 
 
+def _resolve_color_method(color_method, color_provided=False, logger=None):
+    """Resolve color_method to one of {'STATE','NODE'}.
+
+    AUTO resolves to NODE when user-supplied colors are provided, otherwise
+    to STATE so state/activity colors remain the default behavior.
+    """
+    cm = str('AUTO' if color_method is None else color_method).upper()
+    if cm == 'AUTO':
+        resolved = 'NODE' if color_provided else 'STATE'
+        if logger is not None:
+            logger.info('[Movingbubbles] color_method="auto" resolved to [%s].' % (resolved.lower()))
+        return resolved
+    if cm not in {'STATE', 'NODE'}:
+        if logger is not None:
+            logger.warning('[Movingbubbles] Unknown color_method [%s]. Falling back to [state].' % (cm))
+        return 'STATE'
+    return cm
+
+
 # %% Set configuration properties
 def set_config(config={}, **kwargs):
     """Set the default configuration settings."""
@@ -50,7 +69,12 @@ def set_config(config={}, **kwargs):
     config['dt_format'] = kwargs.get('dt_format', '%d-%m-%Y %H:%M:%S')
     config['columns'] = kwargs.get('columns', {'datetime': config['datetime'], 'sample_id': config['sample_id'], 'state': config['state']})
     config['notebook'] = kwargs.get('notebook', False)
-    config['color_method'] = kwargs.get('color_method', "STATE")
+    config['color_provided'] = kwargs.get('color_provided', kwargs.get('color', None) is not None)
+    config['color_method'] = _resolve_color_method(
+        kwargs.get('color_method', 'AUTO'),
+        color_provided=config['color_provided'],
+        logger=logger,
+    )
     config['save_button'] = kwargs.get('save_button', True)
     config['show_side_panel'] = kwargs.get('show_side_panel', True)
     config['show_top_panel'] = kwargs.get('show_top_panel', True)
@@ -173,7 +197,8 @@ def set_edge_properties(df, **kwargs):
     color = kwargs.get('color', None)
     opacity = kwargs.get('opacity', 0.6)
     stroke = kwargs.get('stroke', '#000000')
-    cmap = kwargs.get('cmap', 'Set1')
+    config = kwargs.get('config', {})
+    cmap = kwargs.get('cmap', config.get('cmap', 'Set1'))
     dt_format = kwargs.get('dt_format', '%d-%m-%Y %H:%M:%S')
     logger = kwargs.get('logger', None)
     df = df.copy()
@@ -205,28 +230,46 @@ def _array_like_len_check(name, values, n):
         raise Exception('[Movingbubbles] Input parameter [%s] as an array/list/Series must have the same length as the input dataframe: expected %d, got %d.' % (name, n, len(values)))
 
 
+def _is_hex_color(value):
+    return isinstance(value, str) and bool(re.fullmatch(r'#[0-9a-fA-F]{6}', value))
+
+
+def _labels_to_hex(labels, cmap):
+    labels = pd.Series(labels, copy=False).astype(str).values
+    colors = colourmap.fromlist(labels, cmap=cmap, scheme='hex', method='matplotlib', verbose=0)[0]
+    return [str(c) for c in colors]
+
+
 def _set_nodecolor(df, sample_id, color, cmap, logger):
     if isinstance(color, dict):
-        # Per-node colors supplied as {sample_id: hex}
+        # Per-node colors supplied as {sample_id: color}. Values can be hex
+        # colors or categorical labels that are mapped via cmap.
         if logger is not None: logger.info('Processing the specified node colors as a dictionary..')
         df['color'] = '#808080'
-        for key in color.keys():
-            df.loc[df[sample_id]==key, 'color'] = str(color.get(key))
+        keys = list(color.keys())
+        vals = list(color.values())
+        if len(vals) > 0 and not np.all([_is_hex_color(v) for v in vals]):
+            vals = _labels_to_hex(vals, cmap)
+        for key, val in zip(keys, vals):
+            df.loc[df[sample_id] == key, 'color'] = str(val)
     elif isinstance(color, (list, tuple, np.ndarray, pd.Series)):
         # Array-like, aligned positionally with the dataframe rows.
         color_arr = np.asarray(color)
         _array_like_len_check('color', color_arr, len(df))
-        if logger is not None: logger.info('Processing the specified node colors as an array aligned with the dataframe..')
-        df['color'] = [str(c) for c in color_arr]
+        if np.all([_is_hex_color(v) for v in color_arr]):
+            if logger is not None: logger.info('Processing the specified node colors as hex colors aligned with the dataframe..')
+            df['color'] = [str(c) for c in color_arr]
+        else:
+            if logger is not None: logger.info('Processing the specified node colors as labels aligned with the dataframe and mapping via cmap..')
+            df['color'] = _labels_to_hex(color_arr, cmap)
     elif color is None:
         # Derive colors from cmap based on sample_id
-        colors = colourmap.fromlist(df[sample_id], cmap=cmap, scheme='hex')[0]
-        df['color'] = [str(c) for c in colors]
+        df['color'] = _labels_to_hex(df[sample_id], cmap)
     else:
         # Single hex color string applied to all nodes
         df['color'] = str(color)
         if logger is not None: logger.info('Set all nodes to color: %s' %(color))
-
+    
     return df
 
 
@@ -331,6 +374,10 @@ def show(df, **kwargs):
     sid_col = config['columns']['sample_id']
     sid = np.array(list(map(lambda x: labels.get(x)['id'], df[config['columns']['state']].values)))
     uiid = np.unique(df[sid_col])
+    # size/opacity schedules: one list per sample, aligned with that sample's
+    # activity steps so the frontend can update radius/opacity on state change.
+    node_size_sched = []
+    node_opacity_sched = []
     for i in uiid:
         # Combine the sample_id with its time in state
         Iloc=df[sid_col]==i
@@ -346,19 +393,25 @@ def show(df, **kwargs):
         # Make one big happy list
         X.append(tmplist)
 
-    # Node size in the same order as the uiid
-    nodedict = dict(zip(df[sid_col], df['size']))
-    config['node_size'] = [int(nodedict.get(x)) if isinstance(nodedict.get(x), (np.integer, int)) else nodedict.get(x) for x in uiid]
+        size_vals = df['size'].loc[Iloc].values
+        node_size_sched.append([
+            int(v) if isinstance(v, (np.integer, int)) else float(v)
+            for v in size_vals
+        ])
+        opacity_vals = df['opacity'].loc[Iloc].values
+        node_opacity_sched.append([float(v) for v in opacity_vals])
+
+    # Per-sample size/opacity schedules (list of lists, same order as uiid /
+    # schedule steps). Frontend uses index 0 at start and updates on each
+    # activity transition so size/opacity track the current state.
+    config['node_size'] = node_size_sched
+    config['node_opacity'] = node_opacity_sched
 
     # Node color in the same order as the uiid
     nodedict = dict(zip(df[sid_col], df['color']))
     # Convert NumPy strings to regular Python strings for proper JSON serialization
     config['node_color'] = [str(nodedict.get(x)) if nodedict.get(x) is not None else nodedict.get(x) for x in uiid]
 
-    # Node opacity in the same order as the uiid
-    nodedict = dict(zip(df[sid_col], df['opacity']))
-    config['node_opacity'] = [float(nodedict.get(x)) for x in uiid]
-
     # Node stroke color in the same order as the uiid
     nodedict = dict(zip(df[sid_col], df['stroke']))
     config['node_stroke'] = [str(nodedict.get(x)) if nodedict.get(x) is not None else nodedict.get(x) for x in uiid]
@@ -523,7 +576,11 @@ def write_html(X, config, logger=None):
     zero_to_min = "0" if config['start_minute']<10 else ""
 
     # Set the selectionbox correctly on the form
-    config['color_method'] = config['color_method'].upper()
+    config['color_method'] = _resolve_color_method(
+        config.get('color_method', 'AUTO'),
+        color_provided=config.get('color_provided', False),
+        logger=logger,
+    )
     SELECTED_STATE = {'STATE': '', 'NODE': ''}
     SELECTED_STATE[config['color_method']] = 'selected="selected"'
     bg_dark, bg_light = resolve_color_background(config.get('color_background'))
@@ -553,6 +610,7 @@ def write_html(X, config, logger=None):
         'NOTE': config['note'],
         'TIME_NOTES': config['time_notes'],
         'COLOR_METHOD': config['color_method'],
+        'COLOR_PROVIDED': 'true' if config.get('color_provided', False) else 'false',
         'START_HOUR_MIN': config['start_hour'] + (config['start_minute'] / 60),
         'START_TIME': zero_to_hour + str(config['start_hour']) + ":" + zero_to_min + str(config['start_minute']),
         'TIMEDELTA': config['timedelta'],

{d3blocks-2.3.0 → d3blocks-2.3.1}/d3blocks/movingbubbles/d3js/movingbubbles.html.j2

@@ -260,9 +260,23 @@ var notes_index = 0;
 var colorByActivity = {{ COLORBYACTIVITY }} // array of the colors per state
 
 // NODE PROPERTIES
-var node_size = {{ NODE_SIZE }}; //array of radius values, one for each node
+var node_size = {{ NODE_SIZE }}; // per-node size schedule: list of lists (one value per activity step), or legacy flat array
 var node_color = {{ NODE_COLOR }}; //array of color values, one for each node
-var node_opacity = {{ NODE_OPACITY }}; //array of opacity values, one for each node
+var node_opacity = {{ NODE_OPACITY }}; // per-node opacity schedule: list of lists (one value per activity step), or legacy flat array
+
+// Resolve size/opacity for node i at schedule step idx.
+// Supports both schedule arrays (list-of-lists from Python) and legacy
+// flat arrays / scalars (one value per node).
+function sizeAt(i, idx) {
+	var s = node_size[i];
+	if (Array.isArray(s)) return +s[Math.min(idx, s.length - 1)];
+	return +s;
+}
+function opacityAt(i, idx) {
+	var o = node_opacity[i];
+	if (Array.isArray(o)) return +o[Math.min(idx, o.length - 1)];
+	return +o;
+}
 var node_stroke = {{ NODE_STROKE }}; //array of stroke colors, one for each node
 var nodeTextInside = {{ nodeTextInside }}; //true: labels centered inside the node; false: labels above it
 
@@ -283,10 +297,15 @@ var PROP_KEYS = {{ PROP_KEYS }};   // ordered list of all selectable variables
 var STATE_COL = {{ STATE_COL }};   // name of the state column (live-updated)
 var SAMPLE_ID_COL = {{ SAMPLE_ID_COL }};
 var color_method = "{{ COLOR_METHOD }}"; //Nodes can be colored based on "STATE" or "NODE"
+var color_provided = {{ COLOR_PROVIDED }};
+var COLOR_MODE_STATE = "__mode_state__";
+var COLOR_MODE_CUSTOM = "__mode_custom__";
+var customColorLabel = color_provided ? "custom" : "node";
 // Layout-panel overrides (null = use defaults / color_method)
 var layoutSizeKey = null;
 var layoutColorKey = null;
 var layoutColorScale = null; // function(value) -> color, when layoutColorKey is set
+var colorModeInitialized = false;
 var currentShapeMode = "circle"; // circle|square|triangle|diamond
 var categoricalShapeMap = null;
 var categoricalShapeKey = null;
@@ -420,13 +439,14 @@ var nodes = sched_objs.map(function(o, i) {
 		act: act,
 		x: init_x,
 		y: init_y,
-		radius: node_size[i], //use the i-th value from the node_size array to set the radius of the i-th node
+		radius: sizeAt(i, 0),
         color: (color_method === "STATE" ? color(act) : node_color[i]),
-		opacity: node_opacity[i],
+		opacity: opacityAt(i, 0),
 		stroke: node_stroke[i],
 		moves: 0,
 		next_move_time: o[0].duration,
 		sched: o,
+		nodeIndex: i,
 		props: (node_props && node_props[i]) ? node_props[i] : {},
 		shape: "circle",
 	}
@@ -730,11 +750,18 @@ function timer() {
 			curr_node.cx = foci[curr_node.act].x;
 			curr_node.cy = foci[curr_node.act].y;
 		
+			// Update size/opacity for the new state (schedule-aligned).
+			// baseNodeRadii drives recomputeRadii() so size multiplier /
+			// layout size-by-variable still apply on top.
+			baseNodeRadii[i] = sizeAt(i, curr_moves);
+			curr_node.opacity = opacityAt(i, curr_moves);
+		
 			nodes[i].next_move_time += nodes[i].sched[ curr_node.moves ].duration;
 		}
 
 	});
 
+	if (typeof recomputeRadii === 'function') recomputeRadii();
 	force.resume();
 	curr_minute += 1;
 
@@ -817,9 +844,13 @@ function tick(e) {
 	//}
 
 	// Base color from state/node, unless Layout→Color overrides it.
-	// Special case: coloring by the state column uses the *live* activity.
-	if (layoutColorKey && layoutColorKey === STATE_COL) {
+	// Special cases:
+	// - COLOR_MODE_STATE: live activity colors
+	// - COLOR_MODE_CUSTOM: original node colors (custom/node)
+	if (layoutColorKey === COLOR_MODE_STATE || layoutColorKey === STATE_COL) {
 		o.color = color(curr_act);
+	} else if (layoutColorKey === COLOR_MODE_CUSTOM) {
+		o.color = node_color[i];
 	} else if (layoutColorKey && layoutColorScale && o.props) {
 		var pv = o.props[layoutColorKey];
 		o.color = (pv != null && pv !== '') ? layoutColorScale(pv) : (color_method === "STATE" ? color(curr_act) : node_color[i]);
@@ -836,6 +867,7 @@ function tick(e) {
   circle
 	  .each(collide(.5))
 	  .style("fill", function(d) { return d.color; })
+	  .style("opacity", function(d) { return d.opacity; })
 	  .attr("d", function(d) { return shapePath(shapeForNode(d), d.radius); })
 	  .attr("transform", function(d) { return "translate(" + d.x + "," + d.y + ")"; });
 
@@ -945,15 +977,18 @@ function resetSimulation(keepSpeed) {
 	for (k in act_counts) {
 		if (Object.prototype.hasOwnProperty.call(act_counts, k)) act_counts[k] = 0;
 	}
-	nodes.forEach(function (n) {
+	nodes.forEach(function (n, i) {
 		var act = n.sched[0].act;
 		n.act = act;
 		n.moves = 0;
 		n.next_move_time = n.sched[0].duration;
 		n.x = foci[act].x + Math.random();
 		n.y = foci[act].y + Math.random();
+		baseNodeRadii[i] = sizeAt(i, 0);
+		n.opacity = opacityAt(i, 0);
 		act_counts[act] += 1;
 	});
+	if (typeof recomputeRadii === 'function') recomputeRadii();
 
 	// Clear selection (trails are intentionally left alone -- only the
 	// "Clear trails" button should remove them; Reset restarts positions
@@ -1289,8 +1324,14 @@ function applyColorMode(key) {
 	layoutColorKey = key || null;
 	layoutColorScale = null;
 	if (!key) return;
-	// State column: live activity colors (handled in tick via color()).
-	if (key === STATE_COL) return;
+	// Built-in base color modes.
+	if (key === COLOR_MODE_STATE || key === COLOR_MODE_CUSTOM) return;
+	// Backward-compatibility: if state column value is selected, treat it as
+	// live state coloring mode.
+	if (key === STATE_COL) {
+		layoutColorKey = COLOR_MODE_STATE;
+		return;
+	}
 	if (isNumericProp(key)) {
 		var vals = numericValues(key);
 		var min = d3.min(vals), max = d3.max(vals);
@@ -1368,6 +1409,10 @@ function initLayoutPropertyControls() {
 
 	var prevSize = sizeSelect ? sizeSelect.value : '';
 	var prevColor = colorSelect ? colorSelect.value : '';
+	if (!colorModeInitialized) {
+		prevColor = (color_method === "STATE") ? COLOR_MODE_STATE : COLOR_MODE_CUSTOM;
+		colorModeInitialized = true;
+	}
 	var prevShape = shapeSelect ? shapeSelect.value : 'circle';
 	var prevLabel = labelSelect ? labelSelect.value : '';
 
@@ -1387,12 +1432,17 @@ function initLayoutPropertyControls() {
 		o.textContent = label;
 		select.appendChild(o);
 	}
+	// Built-in base color modes are always available in the Color dropdown.
+	addOpt(colorSelect, COLOR_MODE_STATE, "state");
+	addOpt(colorSelect, COLOR_MODE_CUSTOM, customColorLabel);
+
 	keys.forEach(function (k) {
 		if (!isVarEnabled(k)) return;
 		// State is always categorical for layout purposes.
 		var numeric = (k !== STATE_COL) && isNumericProp(k);
 		if (numeric) addOpt(sizeSelect, k, k);
-		addOpt(colorSelect, k, k);
+		// STATE_COL has a dedicated built-in mode label "state".
+		if (k !== STATE_COL) addOpt(colorSelect, k, k);
 		if (!numeric) addOpt(shapeSelect, "prop:" + k, k);
 		addOpt(labelSelect, k, k);
 	});
@@ -1409,7 +1459,8 @@ function initLayoutPropertyControls() {
 		applySizeMode(sizeSelect.value);
 	}
 	if (colorSelect) {
-		colorSelect.value = hasOption(colorSelect, prevColor) ? prevColor : '';
+		var colorFallback = (color_method === "STATE") ? COLOR_MODE_STATE : COLOR_MODE_CUSTOM;
+		colorSelect.value = hasOption(colorSelect, prevColor) ? prevColor : colorFallback;
 		applyColorMode(colorSelect.value);
 	}
 	if (shapeSelect) {
@@ -1523,11 +1574,11 @@ if (clearTrailsBtn) clearTrailsBtn.addEventListener("click", function () {
 var layoutResetBtn = document.getElementById("layoutResetBtn");
 if (layoutResetBtn) layoutResetBtn.addEventListener("click", function () {
 	if (layoutSizeSelect) layoutSizeSelect.value = "";
-	if (layoutColorSelect) layoutColorSelect.value = "";
+	if (layoutColorSelect) layoutColorSelect.value = (color_method === "STATE") ? COLOR_MODE_STATE : COLOR_MODE_CUSTOM;
 	if (layoutShapeSelect) layoutShapeSelect.value = "circle";
 	if (layoutLabelSelect) layoutLabelSelect.value = "";
 	applySizeMode("");
-	applyColorMode("");
+	applyColorMode(layoutColorSelect ? layoutColorSelect.value : "");
 	applyShapeMode("circle");
 	applyLabelMode("");
 });
@@ -1595,15 +1646,18 @@ function scrubToMinute(targetMinute) {
 		if (Object.prototype.hasOwnProperty.call(act_counts, k)) act_counts[k] = 0;
 	}
 
-	nodes.forEach(function (n) {
+	nodes.forEach(function (n, i) {
 		var s = nodeStateAtMinute(n, targetMinute);
 		n.act  = s.act;
 		n.moves = s.moves;
 		n.next_move_time = s.next_move_time;
+		baseNodeRadii[i] = sizeAt(i, s.moves);
+		n.opacity = opacityAt(i, s.moves);
 		// Do NOT snap x/y — let the force layout pull each bubble
 		// smoothly toward its new focus so nothing teleports or explodes.
 		act_counts[n.act] += 1;
 	});
+	if (typeof recomputeRadii === 'function') recomputeRadii();
 
 	curr_minute = targetMinute;
 

d3blocks-2.3.1/d3blocks/tests/test_movingbubbles_color.py

@@ -0,0 +1,93 @@
+import colourmap
+import pandas as pd
+
+from d3blocks.movingbubbles.Movingbubbles import set_config, set_edge_properties
+
+
+def _make_df():
+    return pd.DataFrame(
+        {
+            "row_id": [0, 1, 2, 3],
+            "datetime": pd.to_datetime(
+                [
+                    "2023-01-01 00:00:00",
+                    "2023-01-01 00:01:00",
+                    "2023-01-01 00:02:00",
+                    "2023-01-01 00:03:00",
+                ]
+            ),
+            "sample_id": [1, 2, 1, 2],
+            "state": ["A", "B", "A", "B"],
+        }
+    )
+
+
+def test_movingbubbles_color_series_categories_uses_cmap():
+    df = _make_df()
+    categories = pd.Series(["Netherlands", "Germany", "Netherlands", "Norway"])
+
+    out = set_edge_properties(
+        df,
+        datetime="datetime",
+        sample_id="sample_id",
+        state="state",
+        color=categories,
+        standardize="samplewise",
+        timedelta="minutes",
+        config={"cmap": "Dark2"},
+    )
+
+    expected = [
+        str(c)
+        for c in colourmap.fromlist(
+            categories.astype(str).values,
+            cmap="Dark2",
+            scheme="hex",
+            method="matplotlib",
+            verbose=0,
+        )[0]
+    ]
+
+    out_by_input_order = out.sort_values("row_id").reset_index(drop=True)
+    assert out_by_input_order["color"].tolist() == expected
+
+
+def test_movingbubbles_color_method_auto_resolves_to_node_when_color_given():
+    cfg = set_config(config={}, color_method="auto", color=["A", "B"])
+    assert cfg["color_method"] == "NODE"
+
+
+def test_movingbubbles_color_method_auto_resolves_to_state_without_color():
+    cfg = set_config(config={}, color_method="auto", color=None)
+    assert cfg["color_method"] == "STATE"
+
+
+def test_movingbubbles_color_dict_categories_uses_cmap():
+    df = _make_df()
+    category_by_sample = {1: "group_a", 2: "group_b"}
+
+    out = set_edge_properties(
+        df,
+        datetime="datetime",
+        sample_id="sample_id",
+        state="state",
+        color=category_by_sample,
+        standardize="samplewise",
+        timedelta="minutes",
+        cmap="Set2",
+    )
+
+    mapped = [
+        str(c)
+        for c in colourmap.fromlist(
+            list(category_by_sample.values()),
+            cmap="Set2",
+            scheme="hex",
+            method="matplotlib",
+            verbose=0,
+        )[0]
+    ]
+    expected_by_row = [mapped[0], mapped[1], mapped[0], mapped[1]]
+
+    out_by_input_order = out.sort_values("row_id").reset_index(drop=True)
+    assert out_by_input_order["color"].tolist() == expected_by_row

{d3blocks-2.3.0 → d3blocks-2.3.1/d3blocks.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: d3blocks
-Version: 2.3.0
+Version: 2.3.1
 Summary: Python package d3blocks.
 Author-email: Erdogan Taskesen <erdogant@gmail.com>
 License-Expression: GPL-3.0-or-later

{d3blocks-2.3.0 → d3blocks-2.3.1}/d3blocks.egg-info/SOURCES.txt

@@ -136,6 +136,7 @@ d3blocks/tests/test_d3blocks.py
 d3blocks/tests/test_erd.py
 d3blocks/tests/test_flowgraph.py
 d3blocks/tests/test_medium_charts.py
+d3blocks/tests/test_movingbubbles_color.py
 d3blocks/tests/test_movingbubbles_timedelta.py
 d3blocks/tests/test_radialgraph.py
 d3blocks/tests/test_sequence.py