sciris 3.4.0__tar.gz → 3.5.1__tar.gz

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

@@ -4,6 +4,20 @@ 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.1 (2026-10-15)
+
+1. `sc.iterobj()` and `sc.search()` are about twice as fast; `sc.iterobj()` no longer descends into classes or NumPy dtypes stored as attributes (e.g. `self.dtype = np.int64`), since their attributes belong to the class rather than the object. To restore the previous behavior, pass `atomic=sc.sc_nested.atomic_with_tuple`.
+1. `sc.search()` no longer matches the root object when searching by key.
+1. `sc.yeartodate()` is about 6 times faster, and now accepts a list or array of years, returning a list of dates (about 40 ns per date).
+
+## 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.1}/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.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sciris
-Version: 3.4.0
+Version: 3.5.1
 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.1}/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.1}/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.1}/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.1}/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.4.0 → sciris-3.5.1}/sciris/sc_datetime.py

@@ -662,29 +662,41 @@ def yeartodate(year, as_date=True, **kwargs):
     Convert a decimal year to a date
 
     Args:
-        year (int, float):  The numerical year to convert to a DateTime
-        as_date (bool): If True (default), return an `sc.date` object, otherwise return a string
+        year (int, float, list, array):  The numerical year (or years) to convert to a date
+        as_date (bool): If True (default), return a `datetime.date` object, otherwise return a string
 
     Returns:
-        An `sc.date` object (default) or string, depending on the `as_date` argument
+        A `datetime.date` object (default) or string, depending on the `as_date` argument; a list of these if a list or array of years is supplied
 
-    **Example**:
+    **Examples**:
 
     ```python
     sc.yeartodate(2010.5) # Returns datetime.date(2010, 7, 2)
+    sc.yeartodate(np.arange(2020, 2021, 1/52)) # Returns a list of weekly dates
     ```
 
     - *New in version 3.2.1.*
+    - *New in version 3.5.1:* faster; list and array inputs
     """
     as_date = kwargs.pop('asdate', as_date) # Handle with or without underscore
-    full_years = int(year)
-    remainder = year - full_years
-    year_days = _get_year_length(full_years).days
-    days = int(np.round(remainder*year_days))
-    base = dt.date(year=full_years, month=1, day=1)
-    out = datedelta(base, days=days)
-    if not as_date:
-        out = str(out)
+
+    if isinstance(year, (list, tuple, np.ndarray)): # Handle multiple years
+        years = np.asarray(year, dtype=float)
+        full_years = years.astype(int) # Truncate, like int()
+        starts = (full_years - 1970).astype('datetime64[Y]') # Start of each year
+        year_days = ((starts + 1).astype('datetime64[D]') - starts.astype('datetime64[D]')).astype(int)
+        days = np.round((years - full_years)*year_days).astype(int)
+        out = (starts.astype('datetime64[D]') + days).tolist() # Convert to a list of datetime.date objects
+        if not as_date:
+            out = [str(d) for d in out]
+    else:
+        full_years = int(year)
+        remainder = year - full_years
+        year_days = _get_year_length(full_years).days
+        days = int(np.round(remainder*year_days))
+        out = dt.date(year=full_years, month=1, day=1) + dt.timedelta(days=days)
+        if not as_date:
+            out = str(out)
     return out
 
 

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

@@ -20,6 +20,7 @@ from .sc_utils import _not_given, _is_given # Allows searching for actual None v
 # Define objects for which it doesn't make sense to descend further -- used here and sc.equal()
 atomic_classes = [np.ndarray, pd.Series, pd.DataFrame, pd.core.indexes.base.Index]
 atomic_with_tuple = atomic_classes + [tuple]
+atomic_types = [type, np.dtype] # Classes and dtypes are also not descended into by sc.iterobj(), but are compared normally by sc.equal()
 
 
 ##############################################################################
@@ -402,7 +403,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
 
@@ -411,15 +412,15 @@ class IterObj:
         atomic_list = sc.tolist(self.atomic)
         if 'default' in atomic_list: # Handle objects to not descend into
             atomic_list.remove('default')
-            base_atomic = atomic_with_tuple
+            base_atomic = atomic_with_tuple + atomic_types
         if 'default-tuple' in atomic_list:
             atomic_list.remove('default-tuple')
-            base_atomic = atomic_classes
+            base_atomic = atomic_classes + atomic_types
         self.atomic = tuple(base_atomic + atomic_list)
 
         # Handle objects to skip
         if isinstance(skip, dict):
-            skip = sc.dcp(skip)
+            skip = dict(skip) # Shallow copy since the values are only read
             skip_keys       = sc.tolist(skip.pop('keys', None))
             skip_ids        = sc.tolist(skip.pop('ids', None))
             skip_subclasses = sc.tolist(skip.pop('subclasses', None))
@@ -481,9 +482,10 @@ class IterObj:
             print(space*len(self._trace) + string)
         return
 
-    def iteritems(self, parent, trace):
+    def iteritems(self, parent, trace, itertype=None):
         """ Return an iterator over items in this object """
-        itertype = self.check_iter_type(parent)
+        if itertype is None:
+            itertype = self.check_iter_type(parent)
         out = None
         if self.custom_iter:
             out = self.custom_iter(parent)
@@ -505,9 +507,7 @@ class IterObj:
                         out = [] # Return nothing if doesn't have __dict__.items() or __slots__, e.g. a weird wrapped function
             else:
                 out = [] # Return nothing if not recognized
-        out = list(out)
-        for i in range(len(out)):
-            out[i] = [parent, trace, *list(out[i])] # Prepend parent and trace to the arguments
+        out = [(parent, trace, k, v) for k,v in out] # Prepend parent and trace to the arguments
         return out
 
     def getitem(self, key, parent):
@@ -542,12 +542,14 @@ class IterObj:
         """ Shortcut to check_iter_type() """
         return check_iter_type(obj, known=self.atomic, custom=self.custom_type)
 
-    def check_proceed(self, key, subobj, newid):
+    def check_proceed(self, key, subobj, newid, itertype=None):
         """ Check if we should process the object, and if so, whether to descend into it """
 
         # If we've already parsed this (iterable) object, skip it, or if aliases=True, process it but don't descend into it again
         in_memo = (newid in self._memo) and (self._memo[newid] > self.recursion)
-        repeat = in_memo and self.check_iter_type(subobj)
+        if in_memo and itertype is None:
+            itertype = self.check_iter_type(subobj)
+        repeat = in_memo and bool(itertype)
         memo_skip = repeat and not self.aliases
         descend = not repeat
         if repeat and self.aliases:
@@ -560,22 +562,23 @@ class IterObj:
         instance_skip = isinstance(subobj, self._skip_instances)
 
         # Finalize
-        skips = [memo_skip, key_skip, id_skip, subclass_skip, instance_skip]
-        proceed = not any(skips)
+        proceed = not (memo_skip or key_skip or id_skip or subclass_skip or instance_skip)
 
         if not proceed and self.verbose: # Just for debugging
+            skips = [memo_skip, key_skip, id_skip, subclass_skip, instance_skip]
             labels = ['memo', 'key', 'id', 'subclass', 'instance']
             pairs = [f'{label}_skip=True' for label,skip in zip(labels, skips) if skip]
             self.indent(f'Skipping "{key}" because {sc.strjoin(pairs)}')
 
         return proceed, descend
 
-    def process_obj(self, parent, trace, key, subobj, newid):
+    def process_obj(self, parent, trace, key, subobj, newid, itertype=None):
         """ Process a single object, returning its trace and its new value """
         self._memo[newid] += 1
         trace = trace + [key]
-        subitertype = self.check_iter_type(subobj)
-        self.indent(f'{len(self)} Trace {trace} | Type "{str(subitertype)}" | {type(subobj)}')
+        subitertype = self.check_iter_type(subobj) if itertype is None else itertype
+        if self.verbose: # Check here to avoid formatting the string
+            self.indent(f'{len(self)} Trace {trace} | Type "{str(subitertype)}" | {type(subobj)}')
         newobj = subobj
         if not (self.leaf and subitertype):
             newobj = self.func(subobj, **self.func_kw)
@@ -604,11 +607,15 @@ class IterObj:
         while queue:
             parent,trace,key,subobj = queue.popleft()
             newid = id(subobj)
-            proceed, descend = self.check_proceed(key, subobj, newid)
+            itertype = self.check_iter_type(subobj) # Calculate once, since it's needed several times
+            proceed, descend = self.check_proceed(key, subobj, newid, itertype=itertype)
             if proceed:
-                newtrace, newobj = self.process_obj(parent, trace, key, subobj, newid) # Process the object
+                newtrace, newobj = self.process_obj(parent, trace, key, subobj, newid, itertype=itertype) # Process the object
                 if descend: # If modifying in place, descend into the new object, since that's what's in the parent now
-                    newitems = self.iteritems(newobj if self.inplace else subobj, newtrace)
+                    if newobj is subobj or not self.inplace:
+                        newitems = self.iteritems(subobj, newtrace, itertype=itertype)
+                    else:
+                        newitems = self.iteritems(newobj, newtrace)
                     if self.depthfirst:
                         queue.extendleft(reversed(newitems)) # extendleft() swaps order, so swap back
                     else:
@@ -620,6 +627,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):
@@ -675,7 +683,7 @@ def iterobj(obj, func=None, inplace=False, copy=False, leaf=False, recursion=0,
         leaf (bool): whether to apply the function only to leaf nodes of the object
         recursion (int): number of recursive steps to allow, i.e. parsing the same objects multiple times (default 0)
         depthfirst (bool): whether to parse the object depth-first (default) or breadth-first
-        atomic (list): a list of known classes to treat as atomic (do not descend into); if 'default', use defaults (e.g. tuple, `np.array`, `pd.DataFrame`); if 'default-tuple', use defaults except for tuples
+        atomic (list): a list of known classes to treat as atomic (do not descend into); if 'default', use defaults (e.g. tuple, `np.array`, `pd.DataFrame`, classes, and NumPy dtypes); if 'default-tuple', use defaults except for tuples
         skip (list/dict): a list of objects to skip over entirely; can also be a dict with "keys", "ids", "subclasses", and/or "instances", which skip each of those
         rootkey (str): the key to list as the root of the object (default `'root'`)
         verbose (bool): whether to print progress
@@ -716,6 +724,7 @@ def iterobj(obj, func=None, inplace=False, copy=False, leaf=False, recursion=0,
     - *New in version 3.1.5:* "recursion" argument; better handling of atomic classes
     - *New in version 3.1.6:* "skip", "depthfirst", "to_df", and "flatten" arguments
     - *New in version 3.4.0:* "aliases" argument
+    - *New in version 3.5.1:* classes and NumPy dtypes are atomic by default
     """
     # Create the object
     io = IterObj(obj=obj, func=func, inplace=inplace, copy=copy, leaf=leaf, recursion=recursion, aliases=aliases, depthfirst=depthfirst,
@@ -962,23 +971,15 @@ def search(obj, query=_not_given, key=_not_given, value=_not_given, type=_not_gi
     flatten = kwargs.pop('flatten', False) # Don't flatten because that will disrupt the matching
     tree = iterobj(obj, **kwargs) # For key matching
 
-    # Do the matching
-    matches = []
-
-    # Match keys
-    if _is_given(key):
-        for k in tree.keys():
-            if check_match(k[-1], key): # Only want the last key of the trace
-                matches.append(k)
-
-    # Match values (including types)
-    if _is_given(value):
-        for k,v in tree.items():
-            if check_match(v, value):
-                matches.append(k)
-
-    # Reassemble dict to maintain order
-    out = sc.objdict({k:v for k,v in tree.items() if k in matches})
+    # Do the matching, keeping the order of the tree
+    match_key = _is_given(key)
+    match_value = _is_given(value)
+    out = {}
+    for k,v in tree.items():
+        is_root = not isinstance(k, tuple) # The root has no key to match
+        if (match_key and not is_root and check_match(k[-1], key)) or (match_value and check_match(v, value)): # Only want the last key of the trace
+            out[k] = v
+    out = sc.objdict(out)
 
     if flatten:
         out = flatten_traces(out)

{sciris-3.4.0 → sciris-3.5.1}/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):