sciris 3.2.6__tar.gz → 3.2.8__tar.gz

{sciris-3.2.6 → sciris-3.2.8}/.github/workflows/schedule_tests.yaml

@@ -2,7 +2,7 @@ name: Sciris cron tests
 on:
   workflow_dispatch:
   schedule:
-    - cron: "0 0 * * 0" # Run every Sunday at midnight
+    - cron: "0 0 * * *" # Run every day at midnight
 
 jobs:
   ci-tests:

{sciris-3.2.6 → sciris-3.2.8}/CHANGELOG.rst

@@ -7,6 +7,15 @@ All major updates to Sciris are documented here.
 
 By import convention, components of the Sciris library are listed beginning with ``sc.``, e.g. ``sc.odict()``.
 
+Version 3.2.8 (2026-02-28)
+--------------------------
+#. Changed resolution order in :class:`sc.objdict() <sc_odict.objdict>` so that dunder attributes (e.g. ``__await__``) are never accidentally set as dict keys. Attempting to set an existing attribute as a key now raises ``KeyError`` instead of ``ValueError``.
+#. Fixed a bug in :class:`sc.profile() <sc_profiling.profile>` that prevented profiling information from being printed for certain combinations of filenames.
+
+Version 3.2.7 (2026-02-18)
+--------------------------
+#. Refactored :class:`sc.asd() <sc_asd.asd>` to be more robust to different parameter inputs and different objective function return values.
+
 Version 3.2.6 (2026-02-12)
 --------------------------
 #. Added :class:`sc.argparse() <sc_odict.argparse>`, a simple argument parser based on ``sc.objdict``.

{sciris-3.2.6/sciris.egg-info → sciris-3.2.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sciris
-Version: 3.2.6
+Version: 3.2.8
 Summary: Fast, flexible tools to simplify scientific Python
 Author-email: Sciris Development Team <info@sciris.org>
 License-Expression: MIT

sciris-3.2.8/context7.json

@@ -0,0 +1,4 @@
+{
+  "url": "https://context7.com/sciris/sciris",
+  "public_key": "pk_RAjZiMtFTxRqXHnY6XFE3"
+}

{sciris-3.2.6 → sciris-3.2.8}/sciris/sc_asd.py

@@ -9,23 +9,55 @@ This algorithm is published as:
 """
 
 import time
+import warnings
 import numpy as np
 import sciris as sc
 
 __all__ = ['asd']
 
 
+def _consistent_shape(userinput, origshape=False):
+    """ Ensure inputs have the right shape and data type. """
+    output = np.reshape(np.array(userinput, dtype='float'), -1)
+    if origshape:
+        return output, np.shape(userinput)
+    return output
+
+
+def _improvement_ratio(fval_old, fval_new, eps=1e-12):
+    """ Compute improvement ratio with divide-by-zero guard
+    
+    Returns fval_old/fval_new, or 1 when both near zero, or a large value when only fval_new is near zero.
+    """
+    if abs(fval_new) < eps and abs(fval_old) < eps:
+        return 1.0
+    if abs(fval_new) < eps:
+        return 1.0 / eps
+    return fval_old / float(fval_new)
+
+
+def _validate_fval(fval, die=True):
+    """ Validate that the objective function returns a scalar """
+    if not sc.isnumber(fval):
+        if isinstance(fval, np.ndarray) and fval.size == 1: # Automatically convert size-1 arrays to scalars
+            fval = fval[0]
+        else:
+            errormsg = f'ASD: The objective function should return a scalar, not: {fval} (type: {type(fval)})'
+            raise ValueError(errormsg)
+    return fval
+
+
 def asd(function, x, args=None, stepsize=0.1, sinc=2, sdec=2, pinc=2, pdec=2,
     pinitial=None, sinitial=None, xmin=None, xmax=None, maxiters=None, maxtime=None,
     abstol=1e-6, reltol=1e-3, stalliters=None, stoppingfunc=None, randseed=None,
-    label=None, verbose=1, minval=0, **kwargs):
+    label=None, verbose=1, minval=0, die=True, **kwargs):
     """
     Optimization using adaptive stochastic descent (ASD). Can be used as a faster
     and more powerful alternative to e.g. :func:`scipy.optimize.minimize()`.
 
-    ASD starts at ``x0`` and attempts to find a local minimizer ``x`` of the function ``func()``.
-    ``func()`` accepts input ``x`` and returns a scalar function value evaluated at ``x``.
-    ``x0`` can be a scalar, list, or Numpy array of any size.
+    ASD starts at ``x`` and attempts to find a local minimizer of the function ``function()``.
+    ``function()`` accepts input ``x`` and returns a scalar function value evaluated at ``x``.
+    ``x`` can be a scalar, list, or Numpy array of any size.
 
     Args:
         function     (func):  The function to minimize
@@ -51,6 +83,7 @@ def asd(function, x, args=None, stepsize=0.1, sinc=2, sdec=2, pinc=2, pdec=2,
         label        (None):  A label to use to annotate the output
         verbose      (1):     How much information to print during the run (max 3); less than one will print out once every 1/verbose steps
         minval       (0):     Minimum value the objective function can take
+        die          (True):  If True, raise when the objective function raises; if False, treat that trial as np.inf and continue
 
     Returns:
         objdict (see below)
@@ -78,13 +111,13 @@ def asd(function, x, args=None, stepsize=0.1, sinc=2, sdec=2, pinc=2, pdec=2,
         result = sc.asd(np.linalg.norm, [1, 2, 3])
         print(result.x)
 
-        # With arguments
-        def my_func(x, scale=1.0, weight=1.0): # Example function with keywords
+        # With arguments: positional via args, or dict of keywords, or keyword arguments
+        def my_func(x, scale=1.0, weight=1.0):  # Example function with keywords
             return abs((x[0] - 1)) + abs(x[1] + 2)*scale + abs(x[2] + 3)*weight
 
         result = sc.asd(my_func, x=[0, 0, 1], args=[0.5, 0.1]) # Option 1 for passing arguments
-        result = sc.asd(my_func, x=[0, 0, 1], args=dict(scale=0.5, weight=0.1)) # Option 1 for passing arguments
-        result = sc.asd(my_func, x=[0, 0, 1], scale=0.5, weight=0.1) # Option 2 for passing arguments
+        result = sc.asd(my_func, x=[0, 0, 1], args=dict(scale=0.5, weight=0.1)) # Option 2 for passing arguments
+        result = sc.asd(my_func, x=[0, 0, 1], scale=0.5, weight=0.1) # Option 3 for passing arguments
 
     Please use the following citation for this method:
 
@@ -97,82 +130,104 @@ def asd(function, x, args=None, stepsize=0.1, sinc=2, sdec=2, pinc=2, pdec=2,
     rng = np.random.default_rng(randseed)
     if verbose >= 2: print(f'ASD: Launching with random seed {randseed}')
 
-    def consistentshape(userinput, origshape=False):
-        """
-        Make sure inputs have the right shape and data type.
-        """
-        output = np.reshape(np.array(userinput, dtype='float'), -1)
-        if origshape: return output, np.shape(userinput)
-        else:         return output
-
-    # Handle inputs and set defaults
-    if maxtime  is None: maxtime  = 3600
-    if maxiters is None: maxiters = 1000
-    maxrangeiters = 100 # Number of times to try generating a new parameter
-    x, origshape = consistentshape(x, origshape=True) # Turn it into a vector but keep the original shape (not necessarily class, though)
-    nparams = len(x) # Number of parameters
-    if not nparams: # pragma: no cover
+    # Reshape initial point and get parameter count
+    x, origshape = _consistent_shape(x, origshape=True)
+    nparams = len(x)
+    maxrangeiters = 100  # Number of times to try generating a new parameter
+
+    # Set defaults in one place
+    if maxtime is None:
+        maxtime = 3600
+    if maxiters is None:
+        maxiters = 1000
+    if label is None:
+        label = ''
+    if stalliters is None:
+        stalliters = 10 * nparams
+    stalliters = int(stalliters)
+    maxiters = int(maxiters)
+    eps = 1e-12
+
+    # Validate input vector length
+    if not nparams:
         errormsg = 'ASD: The length of the input vector cannot be zero'
         raise ValueError(errormsg)
-    if sinc<1: # pragma: no cover
-        print('ASD: sinc cannot be less than 1; resetting to 2')
+
+    # Validate learning rates (must be >= 1)
+    if sinc < 1:
+        errormsg = 'ASD: sinc cannot be less than 1; resetting to 2'
+        if die:
+            raise ValueError(errormsg)
+        warnings.warn(errormsg)
         sinc = 2
-    if sdec<1: # pragma: no cover
-        print('ASD: sdec cannot be less than 1; resetting to 2')
+    if sdec < 1:
+        errormsg = 'ASD: sdec cannot be less than 1; resetting to 2'
+        if die:
+            raise ValueError(errormsg)
+        warnings.warn(errormsg)
         sdec = 2
-    if pinc<1: # pragma: no cover
-        print('ASD: pinc cannot be less than 1; resetting to 2')
+    if pinc < 1:
+        errormsg = 'ASD: pinc cannot be less than 1; resetting to 2'
+        if die:
+            raise ValueError(errormsg)
+        warnings.warn(errormsg)
         pinc = 2
-    if pdec<1: # pragma: no cover
-        print('ASD: pdec cannot be less than 1; resetting to 2')
+    if pdec < 1:
+        errormsg = 'ASD: pdec cannot be less than 1; resetting to 2'
+        if die:
+            raise ValueError(errormsg)
+        warnings.warn(errormsg)
         pdec = 2
 
-    # Set initial parameter selection probabilities -- uniform by default
-    if pinitial is None: probabilities = np.ones(2 * nparams)
-    else:                probabilities = consistentshape(pinitial)
-    if not sum(probabilities): # pragma: no cover
+    # Set initial parameter selection probabilities (uniform by default)
+    if pinitial is None:
+        probabilities = np.ones(2 * nparams)
+    else:
+        probabilities = _consistent_shape(pinitial)
+    if not sum(probabilities):
         errormsg = 'ASD: The sum of input probabilities cannot be zero'
         raise ValueError(errormsg)
 
-    # Handle step sizes
+    # Step sizes
     if sinitial is None:
         stepsizes = abs(stepsize * x)
-        stepsizes = np.concatenate((stepsizes, stepsizes)) # need to duplicate since two for each parameter
+        stepsizes = np.concatenate((stepsizes, stepsizes))  # Two entries per parameter (up/down)
     else:
-        stepsizes = consistentshape(sinitial)
+        stepsizes = _consistent_shape(sinitial)
 
-    # Handle x limits
-    xmin = np.zeros(nparams) - np.inf if xmin is None else consistentshape(xmin)
-    xmax = np.zeros(nparams) + np.inf if xmax is None else consistentshape(xmax)
+    # Parameter bounds
+    xmin = np.zeros(nparams) - np.inf if xmin is None else _consistent_shape(xmin)
+    xmax = np.zeros(nparams) + np.inf if xmax is None else _consistent_shape(xmax)
 
-    # Final input checking
-    if sum(np.isnan(x)): # pragma: no cover
+    # Reject NaN in starting point
+    if sum(np.isnan(x)):
         errormsg = f'ASD: At least one value in the vector of starting points is NaN:\n{x}'
         raise ValueError(errormsg)
-    if label is None: label = ''
-    if stalliters is None: stalliters = 10 * nparams # By default, try 10 times per parameter on average
-    stalliters = int(stalliters)
-    maxiters = int(maxiters)
 
     # Initialization
-    if all(stepsizes == 0): stepsizes += stepsize # Handle the case where all step sizes are 0
-    if any(stepsizes == 0): stepsizes[stepsizes == 0] = np.mean(stepsizes[stepsizes != 0]) # Replace step sizes of zeros with the mean of non-zero entries
-    if args is None: # Reset if no function arguments supplied
+    if all(stepsizes == 0):
+        stepsizes += stepsize
+    if any(stepsizes == 0):
+        stepsizes[stepsizes == 0] = np.mean(stepsizes[stepsizes != 0])
+    if args is None:
         args = []
-    elif isinstance(args, dict): # It's actually kwargs supplied
+    elif isinstance(args, dict):
         kwargs = sc.mergedicts(args, kwargs)
         args = []
-    fval = function(x, *args, **kwargs) # Calculate initial value of the objective function
-    fvalorig = fval # Store the original value of the objective function, since fval is overwritten on each step
-    xorig = x.copy() # Keep the original x, just in case
-
-    # Initialize history
-    abserrorhistory = np.zeros(stalliters) # Store previous error changes
-    relerrorhistory = np.zeros(stalliters) # Store previous error changes
-    fvals = np.zeros(maxiters + 1) # Store all objective function values
-    allsteps = np.zeros((maxiters + 1, nparams)) # Store all parameters
-    fvals[0] = fvalorig # Store initial function output
-    allsteps[0, :] = xorig # Store initial input vector
+
+    # Get initial function value
+    fval = function(x, *args, **kwargs)
+    fval = _validate_fval(fval, die=die)
+    fvalorig = fval
+    xorig = x.copy()
+
+    # Allocate history arrays
+    abserrorhistory = np.zeros(stalliters)
+    relerrorhistory = np.zeros(stalliters)
+    fvals = np.zeros(maxiters + 1)
+    allsteps = np.zeros((maxiters + 1, nparams))
+    fvals[0] = fvalorig
+    allsteps[0, :] = xorig
 
     # Prepare for the loop
     count = 0 # Keep track of how many iterations have occurred
@@ -180,23 +235,23 @@ def asd(function, x, args=None, stepsize=0.1, sinc=2, sdec=2, pinc=2, pdec=2,
     offset = ' ' * 4 # Offset the print statements
     exitreason = 'Unknown exit reason' # Catch everything else
 
-    # Loop
+    # Main optimization loop
     while True:
 
-        # Handle initialization cases
+        # Skip if already at minimum
         if fvalorig == minval:
             exitreason = f'Objective function already at minimum value ({fvalorig}), skipping optimization'
             break
-        elif fvalorig < 0 and verbose:
+        if fvalorig < 0 and verbose:
             print(f'ASD: Warning, negative objective function starting value ({fvalorig:n}) could lead to unexpected behavior')
 
-        # Begin the loop
-        count += 1 # Increment the count
-        if verbose >= 3: print(f'\n\n Count={count} \n x={x} \n probabilities={probabilities} \n stepsizes={stepsizes}')
+        count += 1
+        if verbose >= 3:
+            print(f'\n\n Count={count} \n x={x} \n probabilities={probabilities} \n stepsizes={stepsizes}')
 
-        # Calculate next parameters
-        probabilities = probabilities / sum(probabilities) # Normalize probabilities
-        cumprobs = np.cumsum(probabilities) # Calculate the cumulative distribution
+        # Normalize probabilities and sample a parameter/direction
+        probabilities = probabilities / sum(probabilities)
+        cumprobs = np.cumsum(probabilities)
         inrange = False
         for r in range(maxrangeiters): # Try to find parameters within range
             choice = np.flatnonzero(cumprobs > rng.random())[0] # Choose a parameter and upper/lower at random
@@ -206,93 +261,95 @@ def asd(function, x, args=None, stepsize=0.1, sinc=2, sdec=2, pinc=2, pdec=2,
             if newval<xmin[par]: newval = xmin[par] # Reset to the lower limit
             if newval>xmax[par]: newval = xmax[par] # Reset to the upper limit
             inrange = (newval != x[par])
-            if verbose >= 3: print(offset*2 + f'count={count} r={r}, choice={choice}, par={par}, x[par]={x[par]}, pm={(-1)**pm}, step={stepsizes[choice]}, newval={newval}, xmin={xmin[par]}, xmax={xmax[par]}, inrange={inrange}')
-            if inrange: # Proceed as long as they're not equal
+            if verbose >= 3:
+                print(offset*2 + f'count={count} r={r}, choice={choice}, par={par}, x[par]={x[par]}, pm={(-1)**pm}, step={stepsizes[choice]}, newval={newval}, xmin={xmin[par]}, xmax={xmax[par]}, inrange={inrange}')
+            if inrange:
                 break
         if not inrange: # Treat it as a failure if a value in range can't be found
             probabilities[choice] = probabilities[choice] / pdec
             stepsizes[choice] = stepsizes[choice] / sdec
 
-        # Calculate the new value
-        xnew = x.copy() # Initialize the new parameter set
-        xnew[par] = newval # Update the new parameter set
-        fvalnew = function(xnew, *args, **kwargs) # Calculate the objective function for the new parameter set
-        eps = 1e-12 # Small value to avoid divide-by-zero errors
-        if abs(fvalnew)<eps and abs(fval)<eps: ratio = 1 # They're both zero: set the ratio to 1
-        elif abs(fvalnew)<eps:                 ratio = 1.0/eps # Only the denominator is zero: reset to the maximum ratio
-        else:                                  ratio = fval/float(fvalnew) # The normal situation: calculate the real ratio
-        abserrorhistory[np.mod(count, stalliters)] = max(0, fval-fvalnew) # Keep track of improvements in the error
-        relerrorhistory[np.mod(count, stalliters)] = max(0, ratio-1.0) # Keep track of improvements in the error
-        if verbose >= 2: print(offset + f'step={count} choice={choice}, par={par}, pm={pm}, origval={x[par]}, newval={xnew[par]}')
+        # Evaluate objective at proposed point
+        xnew = x.copy()
+        xnew[par] = newval
+        try:
+            fvalnew = function(xnew, *args, **kwargs)
+            fvalnew = _validate_fval(fvalnew, die=die)
+        except Exception as e:
+            if die:
+                raise
+            warnings.warn(f'ASD: Objective function raised on step {count}; treating trial as np.inf. Error: {e}')
+            fvalnew = np.inf
+        ratio = _improvement_ratio(fval, fvalnew, eps)
+
+        # Update improvement history
+        abserrorhistory[count % stalliters] = max(0, fval - fvalnew)
+        relerrorhistory[count % stalliters] = max(0, ratio - 1.0)
+        if verbose >= 2:
+            print(offset + f'step={count} choice={choice}, par={par}, pm={pm}, origval={x[par]}, newval={xnew[par]}')
         if newval < 0 and verbose:
             print(f'ASD: Warning, negative objective function ({newval:n}) on step {count} could lead to unexpected behavior')
 
-        # Check if this step was an improvement
-        fvalold = fval # Store old fval
-        if fvalnew < fvalold: # New parameter set is better than previous one
-            probabilities[choice] = probabilities[choice] * pinc # Increase probability of picking this parameter again
-            stepsizes[choice] = stepsizes[choice] * sinc # Increase size of step for next time
-            x = xnew # Reset current parameters
-            fval = fvalnew # Reset current error
-            flag = '++' # Marks an improvement
-        else: # New parameter set is the same or worse than the previous one
-            probabilities[choice] = probabilities[choice] / pdec # Decrease probability of picking this parameter again
-            stepsizes[choice] = stepsizes[choice] / sdec # Decrease size of step for next time
-            flag = '--' # Marks no change
-            if np.isnan(fvalnew):
-                if verbose >= 1: print('ASD: Warning, objective function returned NaN')
-        if verbose > 0 and not (count % max(1, int(1.0/verbose))): # Print out every 1/verbose steps
-            orig, best, new, diff = sc.sigfig([fvalorig, fvalold, fvalnew, fvalnew-fvalold])
+        # Accept or reject step and update learning state
+        fvalold = fval
+        if fvalnew < fvalold:
+            probabilities[choice] = probabilities[choice] * pinc
+            stepsizes[choice] = stepsizes[choice] * sinc
+            x = xnew
+            fval = fvalnew
+            flag = '++'
+        else:
+            probabilities[choice] = probabilities[choice] / pdec
+            stepsizes[choice] = stepsizes[choice] / sdec
+            flag = '--'
+            if np.isnan(fvalnew) and verbose >= 1:
+                print('ASD: Warning, objective function returned NaN')
+        if verbose > 0 and not (count % max(1, int(1.0/verbose))):
+            orig, best, new, diff = sc.sigfig([fvalorig, fvalold, fvalnew, fvalnew - fvalold])
             print(offset + label + f' step {count} ({time.time()-start:0.1f} s) {flag} (orig:{orig} | best:{best} | new:{new} | diff:{diff})')
 
-        # Store output information
-        fvals[count] = fval # Store objective function evaluations
-        allsteps[count, :] = x # Store parameters
+        # Record history for this iteration
+        fvals[count] = fval
+        allsteps[count, :] = x
 
         # Stopping criteria
         if count >= maxiters: # Stop if the iteration limit is exceeded # pragma: no cover
             exitreason = 'Maximum iterations reached'
             break
-        if (time.time() - start) > maxtime: # pragma: no cover
+        if (time.time() - start) > maxtime: # Stop if the time limit is exceeded # pragma: no cover
             strtime, strmax = sc.sigfig([(time.time()-start), maxtime])
             exitreason = f'Time limit reached ({strtime} > {strmax})'
             break
-        if (count > stalliters) and (abs(np.mean(abserrorhistory)) < abstol): # Stop if improvement is too small
+        if (count > stalliters) and (abs(np.mean(abserrorhistory)) < abstol): # Stop if absolute improvement is too small
             strabs, strtol = sc.sigfig([np.mean(abserrorhistory), abstol])
             exitreason = f'Absolute improvement too small ({strabs} < {strtol})'
             break
-        if (count > stalliters) and (sum(relerrorhistory) < reltol): # Stop if improvement is too small
+        if (count > stalliters) and (sum(relerrorhistory) < reltol): # Stop if relativeimprovement is too small
             strrel, strtol = sc.sigfig([np.mean(relerrorhistory), reltol])
             exitreason = f'Relative improvement too small ({strrel} < {strtol})'
             break
-        if stoppingfunc and stoppingfunc(): # pragma: no cover
+        if stoppingfunc and stoppingfunc(): # Stop if explicitly requested # pragma: no cover
             exitreason = 'Stopping function called'
             break
-        if fval == minval:
+        if fval == minval: # Stop if the objective function value is at the minimum
             exitreason = f'Minimum objective function value reached ({fval})'
             break
 
-    # Return
+    # Build and return result
     if verbose > 0:
         orig, best = sc.sigfig([fvals[0], fvals[count]])
-        eps = 1e-12 # Small value to avoid divide-by-zero errors
-        if abs(fvals[count])<eps and abs(fvals[0])<eps:
-            ratio = 1 # They're both zero: set the ratio to 1
-        elif abs(fvals[0])<eps:
-            ratio = 1.0/eps # Only the denominator is zero: reset to the maximum ratio
-        else:
-            ratio = fvals[count]/float(fvals[0]) # The normal situation: calculate the real ratio
-
+        ratio = _improvement_ratio(fvals[0], fvals[count], eps)
         print(f'=== {label} {exitreason} ({count} steps, orig: {orig} | best: {best} | ratio: {ratio}) ===')
 
-    output = sc.objdict()
-    output['x'] = np.reshape(x, origshape) # Parameters
-    output['fval'] = fvals[count]
-    output['exitreason'] = exitreason
-    output['details'] = sc.objdict()
-    output['details']['fvals'] = fvals[:count+1] # Function evaluations
-    output['details']['xvals'] = allsteps[:count+1, :]
-    output['details']['probabilities'] = probabilities
-    output['details']['stepsizes'] = stepsizes
-
-    return output # Return parameter vector as well as details about run
+    output = sc.objdict(
+        x = np.reshape(x, origshape), # Parameters
+        fval = fvals[count],
+        exitreason = exitreason,
+        details = sc.objdict(
+            fvals = fvals[:count+1], # Function evaluations
+            xvals = allsteps[:count+1, :],
+            probabilities = probabilities,
+            stepsizes = stepsizes
+        )
+    )
+    return output

{sciris-3.2.6 → sciris-3.2.8}/sciris/sc_odict.py

@@ -5,11 +5,6 @@ Highlights:
     - :class:`sc.odict() <odict>`: flexible container representing the best-of-all-worlds across dicts, lists, and arrays
     - :class:`objdict`: like an odict, but allows get/set via e.g. ``foo.bar`` instead of ``foo['bar']``
 """
-
-##############################################################################
-#%% odict class
-##############################################################################
-
 import re
 import sys
 import json
@@ -67,6 +62,11 @@ class counter(co.Counter):
                 raise AttributeError(errormsg) from e
 
 
+##############################################################################
+#%% odict class
+##############################################################################
+
+
 class odict(dict):
     """
     Ordered dictionary with integer indexing
@@ -138,7 +138,7 @@ class odict(dict):
             if defaultdict != 'nested' and not callable(defaultdict): # pragma: no cover
                 errormsg = f'The defaultdict argument must be either "nested" or callable, not {type(defaultdict)}'
                 raise TypeError(errormsg)
-            self._setattr('_defaultdict', defaultdict) # Use dict.__setattr__() since setattr() is overridden by sc.objdict()
+            self._setattr('_defaultdict', defaultdict) # Use object.__setattr__() since setattr() is overridden by sc.objdict()
 
         self._cache_keys()
         return
@@ -158,8 +158,8 @@ class odict(dict):
 
 
     def _setattr(self, key, value):
-        """ Shortcut to dict method """
-        return dict.__setattr__(self, key, value)
+        """ Shortcut to object method """
+        return object.__setattr__(self, key, value)
 
 
     def _setitem(self, key, value):
@@ -179,7 +179,7 @@ class odict(dict):
             if isinstance(key, sc._stringtypes) or isinstance(key, tuple): # Normal use case: just use a string key
                 if isinstance(E, KeyError): # We already encountered an exception, usually a KeyError
                     try: # Handle defaultdict behavior by first checking if it exists
-                        _defaultdict = dict.__getattribute__(self, '_defaultdict')
+                        _defaultdict = object.__getattribute__(self, '_defaultdict')
                     except:
                         _defaultdict = None
                     if _defaultdict is not None and allow_default: # If it does, use it, then get the key again
@@ -1208,8 +1208,8 @@ class objdict(odict):
         nested_parent = kwargs.pop('_nested_parent', None)
         nested_attr  = kwargs.pop('_nested_attr', None)
         if nested_parent is not None:
-            odict.__setattr__(self, '_nested_parent', nested_parent)
-            odict.__setattr__(self, '_nested_attr', nested_attr)
+            object.__setattr__(self, '_nested_parent', nested_parent)
+            object.__setattr__(self, '_nested_attr', nested_attr)
         odict.__init__(self, *args, **kwargs) # Standard init
         return
 
@@ -1226,22 +1226,22 @@ class objdict(odict):
             return object.__getattribute__(self, attr)
         else:
             try: # First, try to get the attribute as an attribute
-                return odict.__getattribute__(self, attr)
+                return object.__getattribute__(self, attr)
             except Exception as E: # If that fails, try to get it as a dict item, but pass along the original exception
                 return self.__getitem__(attr, exception=E)
 
 
     def __setattr__(self, name, value):
         """ Set key in dict, not attribute! """
-        try:
-            odict.__getattribute__(self, name) # Try retrieving this as an attribute, expect AttributeError...
-            if name[:2] == '__': # If it starts with a double underscore, it's almost certainly an attribute, not a key
-                odict.__setattr__(self, name, value)
-            else:
+        if name[:2] == '__': # If it starts with a double underscore, it's almost certainly an attribute, not a key
+            return object.__setattr__(self, name, value)
+        else:
+            try:
+                object.__getattribute__(self, name) # Try retrieving this as an attribute, expect AttributeError...
                 errormsg = f'"{name}" exists as an attribute, so cannot be set as key; use setattribute() instead'
-                raise ValueError(errormsg)
-        except AttributeError:
-            return self.__setitem__(name, value) # If so, simply return
+                raise KeyError(errormsg)
+            except AttributeError:
+                return self.__setitem__(name, value) # If so, simply return
 
 
     def __getitem__(self, attr, exception=None):
@@ -1250,7 +1250,7 @@ class objdict(odict):
             return odict.__getitem__(self, attr, allow_default=False) # Do not allow odict to handle default
         except Exception as E2: # If that fails, raise the original exception
             try: # Handle defaultdict behavior by first checking if it exists
-                _defaultdict = odict.__getattribute__(self, '_defaultdict')
+                _defaultdict = object.__getattribute__(self, '_defaultdict')
             except:
                 _defaultdict = None
             if _defaultdict is not None: # If it does, use it, then get the key again
@@ -1288,13 +1288,13 @@ class objdict(odict):
         try:
             del self[name]
         except: # pragma: no cover
-            odict.__delattr__(self, name)
+            object.__delattr__(self, name)
         return
 
 
     def getattribute(self, name):
         """ Get attribute if truly desired """
-        return odict.__getattribute__(self, name)
+        return object.__getattribute__(self, name)
 
 
     def setattribute(self, name, value, force=False):
@@ -1302,12 +1302,12 @@ class objdict(odict):
         if hasattr(self.__class__, name) and not force:
             errormsg = f'objdict attribute "{name}" is read-only'
             raise AttributeError(errormsg)
-        return odict.__setattr__(self, name, value)
+        return object.__setattr__(self, name, value)
 
 
     def delattribute(self, name):
         """ Delete attribute if truly desired """
-        return odict.__delattr__(self, name)
+        return object.__delattr__(self, name)
 
 
 class dictobj(dict):

{sciris-3.2.6 → sciris-3.2.8}/sciris/sc_profiling.py

@@ -580,7 +580,10 @@ class profile(sc.prettyobj):
                     context_stack.pop()
 
                 def visit_FunctionDef(self, node):
-                    if node.lineno == lineno:
+                    # Check def line and decorator lines; in Python 3.11+,
+                    # co_firstlineno points to the first decorator, not the def
+                    match_lines = {node.lineno} | {d.lineno for d in node.decorator_list}
+                    if lineno in match_lines:
                         context_stack.append(node.name)
                         nonlocal name
                         name = '.'.join(context_stack)
@@ -656,8 +659,17 @@ class profile(sc.prettyobj):
             )
             self.output[name] = entry
 
-        # The last name extracted is the name of the function that was run
-        self.run_func_name = name
+        # Determine the name of the run function from the actual function object
+        # (can't assume the last chunk since line_profiler may sort by filename)
+        run_func = self.run_func
+        if hasattr(run_func, '__func__'):
+            run_func = run_func.__func__
+        if hasattr(run_func, '__code__'):
+            run_file = run_func.__code__.co_filename
+            run_lineno = run_func.__code__.co_firstlineno
+            self.run_func_name = self._path_to_name(run_file, run_lineno)
+        else:
+            self.run_func_name = name # Fallback to last chunk
 
         # Sort and convert to dataframe
         self.sort()

{sciris-3.2.6 → sciris-3.2.8}/sciris/sc_version.py

@@ -4,6 +4,6 @@ Version and license information.
 
 __all__ = ['__version__', '__versiondate__', '__license__']
 
-__version__      = '3.2.6'
-__versiondate__  = '2026-02-12'
+__version__      = '3.2.8'
+__versiondate__  = '2026-02-28'
 __license__      = f'Sciris {__version__} ({__versiondate__}) – © 2014-2026 by the Sciris Development Team'