sciris 3.4.0__tar.gz → 3.5.0__tar.gz

{sciris-3.4.0 → sciris-3.5.0}/CHANGELOG.md

@@ -4,6 +4,14 @@ 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.5.0 (2026-10-13)
+
+1. `sc.obj()` is a new, shorter name for `sc.objdict()`, e.g. `pars = sc.obj(a=1, b=2)`. It is the preferred name for new code.
+1. `sc.objdict()` is now much faster: reading a key as an attribute (`obj.a`) is about 10 times faster, setting one (`obj.a = 1`) is about 4 times faster, and looking up a method (`obj.items`) is about 3 times faster. Creating an `sc.odict()` or `sc.objdict()` is about twice as fast, and `sc.iterobj()` and `sc.search()` are faster too.
+1. `sc.dictobj()` now stores its keys in the dict itself, so it works with `json.dumps()` and other functions that expect a plain dict. Item access (`obj['a']`) is about 5 times faster. Files saved with earlier versions can still be loaded.
+1. As a guide to which to use: `sc.dictobj()` is nearly as fast as a plain `dict` (about 15–20 ns to get or set a key either way, versus 10–15 ns for a `dict`), while `sc.objdict()` takes about 40–50 ns to get a key and 200–300 ns to set one, in exchange for the extra features of `sc.odict()` (such as indexing by position) and for protecting its methods from being overwritten by keys. So use `sc.objdict()` by default, and `sc.dictobj()` or a `dict` in loops that run millions of times.
+1. For subclasses of `sc.objdict()` with properties: if a property raises an exception, that exception is now always raised (previously, a key with the same name would be returned instead); and if a property fails because an attribute is missing, the error message names the property rather than the missing attribute.
+
 ## Version 3.4.0 (2026-09-28)
 
 ### Major changes

{sciris-3.4.0 → sciris-3.5.0}/CLAUDE.md

@@ -14,7 +14,7 @@ This file provides guidance to Claude Code (claude.ai/code) when working with co
 - **Run tests:** `cd tests && ./run_tests`
 - **Install dev:** `pip install -e .`
 - **Build docs:** `cd docs && ./render`
-- **Regenerate API index:** `cd docs && python make_api.py` (updates `docs/api.json`, `docs/llms.txt`, `docs/llms-full.txt`; run after adding, renaming, or changing the signature of any public function, or `tests/test_api.py` will fail)
+- **Generate API index locally:** `cd docs && python make_api.py` (writes `docs/api.json`, `docs/llms.txt`, `docs/llms-full.txt`; these are gitignored, and are built automatically with the docs and published at e.g. https://docs.sciris.org/llms.txt)
 - **Standard import:** `import sciris as sc`
 
 ### Core Functions

{sciris-3.4.0/sciris.egg-info → sciris-3.5.0}/PKG-INFO

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

{sciris-3.4.0 → sciris-3.5.0}/docs/.gitignore

@@ -14,6 +14,11 @@ objects.inv
 # But keep the index.qmd file
 !/api/index.qmd
 
+# Ignore the auto-generated API index (see make_api.py)
+/api.json
+/llms.txt
+/llms-full.txt
+
 **/*.quarto_ipynb
 
 /.quarto/

{sciris-3.4.0 → sciris-3.5.0}/docs/index.qmd

@@ -44,4 +44,4 @@ The entire Sciris API — every public function and class, with its signature, s
 - [llms-full.txt](llms-full.txt): the same, plus a usage example for each function (~90 kB)
 - [api.json](api.json): the same data as structured JSON, for programmatic use
 
-All three files are generated from the source (`cd docs && python make_api.py`) and are verified in CI, so they never drift from the current version of Sciris.
+All three files are generated from the source each time the docs are built, so they never drift from the current version of Sciris. To generate them locally, run `cd docs && python make_api.py`.

{sciris-3.4.0 → sciris-3.5.0}/docs/make_api.py

@@ -13,22 +13,18 @@ published with the docs (e.g. <https://docs.sciris.org/llms.txt>):
 
 This is a docs build tool: nothing here is part of the Sciris package itself.
 
-To regenerate the artifacts::
+The artifacts are not committed to the repository: they are generated when the
+docs are built. To generate them manually::
 
     cd docs && python make_api.py
-
-To check that they are up to date (used by the test suite, hence CI)::
-
-    cd docs && python make_api.py --check
 """
 
 import re
-import sys
 import inspect
 import textwrap
 import sciris as sc
 
-__all__ = ['make_index', 'load', 'write', 'check']
+__all__ = ['make_index', 'load', 'write']
 
 thisdir = sc.thispath(__file__)
 jsonfile = thisdir / 'api.json'
@@ -314,44 +310,5 @@ def write(verbose=True):
     return written
 
 
-def check(verbose=True):
-    """
-    Check whether the generated artifacts match the current API.
-
-    Args:
-        verbose (bool): whether to print which files are out of date
-
-    Returns:
-        The list of files that are out of date (empty if everything matches).
-    """
-    index = make_index()
-    stale = []
-
-    def compare(path, expected):
-        """ Compare a file to what it should contain, treating a missing file as stale """
-        if not path.exists():
-            return 'missing'
-        actual = sc.loadjson(path) if path.suffix == '.json' else sc.loadtext(path)
-        return None if actual == expected else 'out of date'
-
-    for path,expected in [(jsonfile, index),
-                          (llmsfile, make_llms_txt(index, examples=False)),
-                          (llmsfullfile, make_llms_txt(index, examples=True))]:
-        reason = compare(path, expected)
-        if reason:
-            stale.append(path)
-            if verbose:
-                print(f'  {path.name} is {reason}')
-    if verbose and not stale:
-        print(f'All API artifacts are up to date ({index["n_entries"]} entries, v{index["version"]})')
-    return stale
-
-
 if __name__ == '__main__':
-    if '--check' in sys.argv:
-        stale = check()
-        if stale:
-            print('Run "python make_api.py" to regenerate.')
-            sys.exit(1)
-    else:
-        write()
+    write()

{sciris-3.4.0 → sciris-3.5.0}/docs/tutorials/tut_dicts.qmd

@@ -101,7 +101,19 @@ print(f'Checking {ob.key1 = }')
 print(f'Checking {ob["key1"] = }') # We need to use double-quotes inside since single quotes are taken!
 ```
 
-In most cases, you probably want to use `objdict`s rather than `odict`s just to have the extra flexibility. Why would you ever use an `odict` over an `objdict`? Mostly just because there's small but nonzero overhead in doing the extra attribute checking: `odict` is faster (faster than even `collections.OrderedDict`, though slower than a plain `dict`). The differences are tiny (literally nanoseconds) so won't matter unless you're doing millions of operations. But if you're reading this, chances are high that you _do_ sometimes need to do millions of dict operations.
+In most cases, you probably want to use `objdict`s rather than `odict`s just to have the extra flexibility. Since they're so common, `sc.obj()` is a shorter name for `sc.objdict()`.
+
+### Performance
+
+All this flexibility has a cost, although a small one. If you only need attribute access and not the other `odict` features (such as indexing by position), `sc.dictobj()` is a lighter-weight alternative that is nearly as fast as a plain `dict`. Approximate times per operation, in nanoseconds:
+
+| | `obj['a']` | `obj.a` | `obj['a'] = 1` | `obj.a = 1` | Create |
+|---|---|---|---|---|---|
+| `dict` | 10 | n/a | 15 | n/a | 50 |
+| `sc.dictobj()` | 20 | 15 | 15 | 20 | 450 |
+| `sc.objdict()` | 40 | 50 | 190 | 330 | 600 |
+
+These differences won't matter unless you're doing millions of operations. But if you're reading this, chances are high that you _do_ sometimes need to do millions of dict operations, in which case use `sc.dictobj()` or a plain `dict` inside the loop. The other difference is that an `sc.objdict()` protects its methods (`obj.keys = 3` raises an error, and `obj['keys'] = 3` leaves `obj.keys()` working), whereas in an `sc.dictobj()` a key replaces a method of the same name.
 
 ## Dataframes
 

sciris-3.5.0/objdict_performance.md

@@ -0,0 +1,89 @@
+# `sc.objdict` attribute access is slow
+
+## Summary
+
+Reading a key from an `sc.objdict` as an attribute (`obj.a`) takes about 530 ns, roughly 35 times slower than `types.SimpleNamespace` or `sc.dictobj` (15 ns) and 6 times slower than reading the same key as an item (`obj['a']`, 90 ns). Writing via an attribute (`obj.a = 1`) takes about 1150 ns, roughly 60 times slower than `SimpleNamespace`. This is invisible in normal use, but it adds up when an `objdict` is read inside a hot loop.
+
+## How it was found
+
+In the Starsim v4 ODE solver (`starsim/solvers.py` on the `v4` branch), the right-hand side function read its per-compartment and per-flow records from `objdict`s. Profiling showed attribute access on those objects was about a third of the right-hand side's run time. Swapping the records read in the hot loop for `types.SimpleNamespace` removed the cost. The solver still uses `objdict` everywhere outside the hot loop.
+
+## Measurements
+
+Sciris 3.4.0, Python 3.13, Linux; best of 5 runs of 1,000,000 operations each.
+
+| Object | `obj.a` | `obj['a']` | `obj.a = 1.0` |
+|---|---|---|---|
+| `dict` | n/a | 10 ns | n/a |
+| `types.SimpleNamespace` | 15 ns | n/a | 19 ns |
+| `sc.odict` | n/a | 65 ns | n/a |
+| `sc.dictobj` | 15 ns | 81 ns | 20 ns |
+| `sc.objdict` | 531 ns | 91 ns | 1148 ns |
+
+```python
+import timeit
+import types
+import sciris as sc
+
+n = 1_000_000
+data = dict(a=1.0, b=2.0, c=3.0)
+objs = dict(
+    SimpleNamespace = types.SimpleNamespace(**data),
+    dictobj         = sc.dictobj(data),
+    objdict         = sc.objdict(data),
+)
+for name,obj in objs.items():
+    for stmt in ['obj.a', 'obj.a = 1.0']:
+        t = min(timeit.repeat(stmt, globals=dict(obj=obj), number=n, repeat=5))/n*1e9
+        print(f'{name:16s} {stmt:12s} {t:6.0f} ns')
+```
+
+## Cause
+
+`objdict.__getattribute__` (in `sciris/sc_odict.py`) tries the name as a real attribute first and falls back to the dict only if that fails:
+
+```python
+try: # First, try to get the attribute as an attribute
+    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)
+```
+
+So every successful read of a key raises and catches an `AttributeError` before reaching the dict, and then goes through two more Python-level calls (`objdict.__getitem__`, then `odict.__getitem__`). Creating and catching the exception is most of the cost.
+
+`objdict.__setattr__` does the same thing: it calls `object.__getattribute__` to check that the name is not an existing attribute, which raises for every ordinary key, and then calls `__setitem__`.
+
+Reading a method or other real attribute (`obj.keys`) does not hit the exception and takes about 90 ns.
+
+## Possible fix
+
+Check the dict first, and use it directly when the name is a key and is not also an attribute of the class. Methods still win over keys of the same name, so behavior is unchanged; everything else falls through to the existing code.
+
+```python
+def __getattribute__(self, attr):
+    if dict.__contains__(self, attr) and not hasattr(type(self), attr): # A key that doesn't shadow a method
+        return dict.__getitem__(self, attr)
+    ... # Existing code
+
+def __setattr__(self, name, value):
+    if dict.__contains__(self, name) and not hasattr(type(self), name): # An existing key
+        return dict.__setitem__(self, name, value)
+    ... # Existing code
+```
+
+Timings for a prototype of this, written as a subclass of `sc.objdict`:
+
+| Operation | Current | Prototype |
+|---|---|---|
+| `obj.a` (existing key) | 532 ns | 62 ns |
+| `obj.a = 1.0` (existing key) | 1178 ns | 101 ns |
+| `obj.keys` (method) | 89 ns | 140 ns |
+| `obj.new = 1.0; del obj['new']` (new key) | 1493 ns | 1819 ns |
+
+Reading and writing existing keys become about 9 and 12 times faster. Method lookups and setting new keys become slower (by about 50 ns and 330 ns), because they now pay for the extra check before falling through; some of that is the overhead of the subclass calling the parent method, which a change made in `objdict` itself would not have.
+
+The prototype passed a few quick checks (a key named `keys` does not shadow the method, integer indexing still works, `defaultdict='nested'` still works), but it has not been run against the Sciris test suite, and nothing in Sciris has been changed.
+
+## Workaround
+
+In a hot loop, read `objdict` keys as items (`obj['a']`), or hold the records in a `types.SimpleNamespace` or `sc.dictobj` instead.

{sciris-3.4.0 → sciris-3.5.0}/sciris/sc_nested.py

@@ -402,7 +402,7 @@ class IterObj:
         # Attributes with initialization required
         self._trace     = []
         self._memo      = co.defaultdict(int)
-        self.output     = sc.objdict()
+        self.output     = {} # Converted to an objdict once the iteration is complete, since it's much faster to populate a dict
         if self.func is None: # If no function provided, define a function that just returns the contents of the current node
             self.func = lambda obj: obj
 
@@ -620,6 +620,7 @@ class IterObj:
                 return self.func(self.obj, **self.func_kw) # Set at the root level
             return self.obj
         else:
+            self.output = sc.objdict(self.output)
             return self.output
 
     def flatten_traces(self, sep='_', inplace=True):

{sciris-3.4.0 → sciris-3.5.0}/sciris/sc_odict.py

@@ -8,18 +8,19 @@ Highlights:
 import re
 import sys
 import json
+import copyreg
 import numpy as np
 import collections as co
 import sciris as sc
 from .sc_utils import _not_given # Imported directly since it's needed at definition time
 
 # Restrict imports to user-facing modules
-__all__ = ['ddict', 'counter', 'odict', 'objdict', 'dictobj', 'asobj', 'argparse']
+__all__ = ['ddict', 'counter', 'odict', 'objdict', 'obj', 'dictobj', 'asobj', 'argparse']
 
 ddict = co.defaultdict # Define alias
 
 # Critical attributes that should be resolved immediately, not via any special handling
-_fundamental_attrs = ['__class__', '__reduce__', '__reduce_ex__', '__getstate__', '__setstate__', '__copy__','__deepcopy__']
+_fundamental_attrs = frozenset(['__class__', '__reduce__', '__reduce_ex__', '__getstate__', '__setstate__', '__copy__','__deepcopy__'])
 
 
 class counter(co.Counter):
@@ -140,6 +141,8 @@ class odict(dict):
     - *New in version 3.1.1:* allow steps in slices; `copy()` now behaves as a standard dict
     """
 
+    _stale = True # The keys are only cached (as a list, for integer lookup) when first needed
+
     def __init__(self, *args, defaultdict=None, **kwargs):
         """ Combine the init properties of both OrderedDict and defaultdict """
 
@@ -154,7 +157,6 @@ class odict(dict):
                 raise TypeError(errormsg)
             self._setattr('_defaultdict', defaultdict) # Use object.__setattr__() since setattr() is overridden by sc.objdict()
 
-        self._cache_keys()
         return
 
 
@@ -240,10 +242,10 @@ class odict(dict):
     def __setitem__(self, key, value):
         """ Allows setitem to support strings, integers, slices, lists, or arrays """
 
-        self._setattr('_stale', True) # Flag to refresh the cached keys
+        object.__setattr__(self, '_stale', True) # Flag to refresh the cached keys
 
         if isinstance(key, (str,tuple)):
-            self._setitem(key, value)
+            dict.__setitem__(self, key, value)
 
         elif isinstance(key, sc._numtype): # Convert automatically from float...dangerous?
             thiskey = key if dict.__contains__(self, key) else self._ikey(key) # As with getitem, an existing key takes precedence
@@ -1260,6 +1262,8 @@ class objdict(odict):
     instead act on dict keys (e.g. `obj['x'] = 3`). If you want to actually get/set
     an attribute, use `obj.getattribute()`/`obj.setattribute()`.
 
+    `sc.obj()` is an alias for `sc.objdict()`.
+
     For a lighter-weight example (an object that acts like a dict), see `sc.dictobj()`.
 
     **Examples**:
@@ -1281,6 +1285,8 @@ class objdict(odict):
 
     For a lighter-weight equivalent (based on `dict` instead of `odict`), see
     `sc.dictobj()`.
+
+    - *New in version 3.5.0:* `sc.obj()` alias; much faster attribute access
     """
 
     def __init__(self, *args, **kwargs):
@@ -1298,40 +1304,41 @@ class objdict(odict):
         return odict.__repr__(self, quote='', numsep='.', classname=self.__class__.__name__, *args, **kwargs)
 
 
-    def __getattribute__(self, attr):
-        """ Handle as attributes first, then as dict keys """
-        # Pickle/copy protocol: must resolve from class, not as dict keys
+    def __getattr__(self, attr):
+        """ Only called if not found as an attribute, so get it as a dict key """
+        if attr not in _fundamental_attrs: # Pickle/copy protocol: must resolve from class, not as dict keys
+            try: # The usual case: it's a key
+                return dict.__getitem__(self, attr)
+            except KeyError:
+                pass
+        errormsg = f"'{type(self).__name__}' object has no attribute '{attr}'"
+        exception = AttributeError(errormsg, name=attr, obj=self)
         if attr in _fundamental_attrs:
-            return object.__getattribute__(self, attr)
-        else:
-            try: # First, try to get the attribute as an attribute
-                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)
+            raise exception
+        return self.__getitem__(attr, exception=exception) # Handle defaults, or else raise the exception
 
 
     def __setattr__(self, name, value):
         """ Set key in dict, not attribute! """
         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)
+        elif name in self.__dict__ or hasattr(type(self), name):
+            errormsg = f'"{name}" exists as an attribute, so cannot be set as key; use setattribute() instead'
+            raise KeyError(errormsg)
         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 KeyError(errormsg)
-            except AttributeError:
-                return self.__setitem__(name, value) # If so, simply return
+            return self.__setitem__(name, value)
 
 
     def __getitem__(self, attr, exception=None):
         """ Handle dict keys, including nested defaultdict logic """
         try: # Try retrieving normally
+            return dict.__getitem__(self, attr)
+        except Exception:
+            pass
+        try: # Then try integers, slices, etc.
             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 = object.__getattribute__(self, '_defaultdict')
-            except:
-                _defaultdict = None
+            _defaultdict = self.__dict__.get('_defaultdict') # Handle defaultdict behavior by first checking if it exists
             if _defaultdict is not None: # If it does, use it, then get the key again
                 if _defaultdict == 'nested':
                     return self._new(defaultdict='nested', _nested_parent=self, _nested_attr=attr) # Create a recursive object with links back to the ultimate parent
@@ -1349,14 +1356,9 @@ class objdict(odict):
     def __setitem__(self, name, value):
         """ Set as a dict item """
         odict.__setitem__(self, name, value)
-        try:
-            p = object.__getattribute__(self, '_nested_parent')
-            key = object.__getattribute__(self, '_nested_attr')
-        except AttributeError:
-            p = None
-            key = None
-        if p is not None:
-            p[key] = self
+        attrs = self.__dict__
+        if '_nested_parent' in attrs:
+            attrs['_nested_parent'][attrs['_nested_attr']] = self
             object.__delattr__(self, '_nested_parent')
             object.__delattr__(self, '_nested_attr')
         return
@@ -1389,6 +1391,9 @@ class objdict(odict):
         return object.__delattr__(self, name)
 
 
+obj = objdict # Define alias
+
+
 class dictobj(dict):
     """
     Lightweight class to create an object that can also act like a dictionary.
@@ -1403,35 +1408,46 @@ class dictobj(dict):
     ```
     For a more powerful alternative, see `sc.objdict()`.
 
-    **Note**: because `dictobj` is halfway between a dict and an object, it can't
-    be automatically converted to a JSON (but will fail silently). Use `to_json()`
-    instead.
+    The keys and the attributes are the same thing (the dict is its own `__dict__`),
+    so it is as fast as a plain object for attributes and nearly as fast as a plain
+    dict for items. This also means that keys can overwrite methods (e.g. `obj.items = 5`).
 
     - *New in version 1.3.0.*
     - *New in version 1.3.1:* inherit from dict
     - *New in version 2.0.0:* allow positional arguments
     - *New in version 3.0.0:* "fromkeys" now a class method; `to_json()` method
     - *New in version 3.1.6:* "copy" returns another dictobj
+    - *New in version 3.5.0:* keys are stored in the dict itself, so e.g. `json.dumps()` works; faster
     """
 
+    def __new__(cls, *args, **kwargs):
+        self = dict.__new__(cls)
+        self.__dict__ = self # Use the dict itself to store the attributes
+        return self
+
     def __init__(self, *args, **kwargs):
-        kwargs = sc.mergedicts(*args, kwargs)
-        for k,v in kwargs.items():
-            self.__dict__[k] = v
+        for arg in args:
+            if arg is not None:
+                self.update(arg)
+        self.update(kwargs)
         return
 
     def __repr__(self):
-        output = 'dictobj(' + self.__dict__.__repr__() + ')'
+        output = 'dictobj(' + dict.__repr__(self) + ')'
         return output
 
-    def to_json(self):
-        """ Export the dictobj to JSON (NB: regular `json.dumps()` does not work) """
-        return json.dumps(self.__dict__)
+    def __reduce__(self):
+        """ Pickle and copy the contents once, rather than as both items and attributes """
+        return (copyreg.__newobj__, (self.__class__,), dict(self))
 
-    @classmethod
-    def fromkeys(cls, *args, **kwargs):
-        """ Create a new dictobj from keys """
-        return cls(dict.fromkeys(*args, **kwargs))
+    def __setstate__(self, state):
+        """ Restore from a pickle or copy, including pickles from before version 3.5.0 """
+        self.update(state)
+        return
+
+    def to_json(self):
+        """ Export the dictobj to JSON """
+        return json.dumps(self)
 
     def copy(self):
         """ Create a shallow copy """
@@ -1439,37 +1455,15 @@ class dictobj(dict):
         new.update(self)
         return new
 
-    # Copy other default dictionary methods
-    def __getitem__( self, *args, **kwargs): return self.__dict__.__getitem__( *args, **kwargs)
-    def __setitem__( self, *args, **kwargs): return self.__dict__.__setitem__( *args, **kwargs)
-    def __contains__(self, *args, **kwargs): return self.__dict__.__contains__(*args, **kwargs)
-    def __len__(     self, *args, **kwargs): return self.__dict__.__len__(     *args, **kwargs)
-    def __iter__(    self, *args, **kwargs): return self.__dict__.__iter__(    *args, **kwargs)
-    def clear(       self, *args, **kwargs): return self.__dict__.clear(       *args, **kwargs)
-    def get(         self, *args, **kwargs): return self.__dict__.get(         *args, **kwargs)
-    def items(       self, *args, **kwargs): return self.__dict__.items(       *args, **kwargs)
-    def keys(        self, *args, **kwargs): return self.__dict__.keys(        *args, **kwargs)
-    def pop(         self, *args, **kwargs): return self.__dict__.pop(         *args, **kwargs)
-    def popitem(     self, *args, **kwargs): return self.__dict__.popitem(     *args, **kwargs)
-    def setdefault(  self, *args, **kwargs): return self.__dict__.setdefault(  *args, **kwargs)
-    def update(      self, *args, **kwargs): return self.__dict__.update(      *args, **kwargs)
-    def values(      self, *args, **kwargs): return self.__dict__.values(      *args, **kwargs)
-    def __reversed__(self, *args, **kwargs): return self.__dict__.__reversed__(*args, **kwargs)
-
-    # The dict storage itself is empty, so comparisons and merges must also use __dict__
-    def __eq__(self, other): return self.__dict__ == (other.__dict__ if isinstance(other, dictobj) else other)
-    def __ne__(self, other): return not self.__eq__(other)
     def __or__(self, other):
         new = self.copy()
         new.update(other)
         return new
+
     def __ror__(self, other):
         new = self.__class__(other)
         new.update(self)
         return new
-    def __ior__(self, other):
-        self.update(other)
-        return self
 
 
 def asobj(obj, strict=True):

{sciris-3.4.0 → sciris-3.5.0}/sciris/sc_version.py

@@ -4,6 +4,6 @@ Version and license information.
 
 __all__ = ['__version__', '__versiondate__', '__license__']
 
-__version__      = '3.4.0'
-__versiondate__  = '2026-09-28'
+__version__      = '3.5.0'
+__versiondate__  = '2026-10-13'
 __license__      = f'Sciris {__version__} ({__versiondate__}) – © 2014-2026 by the Sciris Development Team'

{sciris-3.4.0 → sciris-3.5.0/sciris.egg-info}/PKG-INFO

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

{sciris-3.4.0 → sciris-3.5.0}/sciris.egg-info/SOURCES.txt

@@ -9,6 +9,7 @@ MANIFEST.in
 README.md
 STYLE_GUIDE.md
 context7.json
+objdict_performance.md
 pyproject.toml
 .claude-plugin/marketplace.json
 .github/workflows/publish_docs.yaml
@@ -36,15 +37,12 @@ docs/CNAME
 docs/README.md
 docs/_quarto.yml
 docs/_variables.yml
-docs/api.json
 docs/check_notebooks.py
 docs/clean_all
 docs/clean_outputs.py
 docs/conduct.qmd
 docs/contributing.qmd
 docs/index.qmd
-docs/llms-full.txt
-docs/llms.txt
 docs/make_api.py
 docs/overview.qmd
 docs/preview

{sciris-3.4.0 → sciris-3.5.0}/tests/test_api.py

@@ -1,5 +1,5 @@
 '''
-Test the machine-readable API index (docs/api.json, docs/llms.txt), which is generated by docs/make_api.py.
+Test the machine-readable API index (api.json, llms.txt), which is generated by docs/make_api.py when the docs are built.
 '''
 
 import sys
@@ -67,26 +67,11 @@ def test_llms_txt():
     return full
 
 
-def test_generated_index():
-    sc.heading('Test the generated API index')
-
-    index = make_api.load()
-    assert index['version'] == sc.__version__
-    assert index['n_entries'] == len(index['entries'])
-
-    print('Checking that the generated artifacts are up to date')
-    stale = make_api.check()
-    assert not stale, f'API artifacts are out of date: {stale}. Run "cd docs && python make_api.py" to regenerate.'
-
-    return index
-
-
 #%% Run as a script
 if __name__ == '__main__':
     T = sc.timer()
 
     index = test_make_index()
     text = test_llms_txt()
-    generated = test_generated_index()
 
     T.toc('Done.')

{sciris-3.4.0 → sciris-3.5.0}/tests/test_odict.py

@@ -295,6 +295,8 @@ def test_asobj():
     with pytest.raises(AttributeError):
         myobjdict.setattribute('keys', 4)
 
+    assert sc.obj is sc.objdict # Alias
+
     print('Testing dictobj')
     obj = sc.dictobj(x=4, y=6)
     obj.a = 5
@@ -305,6 +307,11 @@ def test_asobj():
     assert 'x' in json
     assert fk.foo is None
     assert sc.dictobj(x=1) != sc.dictobj(x=2) and sc.dictobj(x=1) == {'x':1} # Compares contents
+    assert sc.loadjson(string=json) == obj == sc.dcp(obj) == sc.loadstr(sc.dumpstr(obj)) # Keys and attributes are the same thing
+    assert isinstance(obj | {'c':1}, sc.dictobj) and isinstance(obj.copy(), sc.dictobj)
+    old = sc.dictobj.__new__(sc.dictobj)
+    old.__setstate__({'x':4}) # Pickles from before 3.5.0 stored the data as attributes
+    assert old.x == old['x'] == 4
 
     return