QuLab 2.3.6__cp310-cp310-macosx_10_9_universal2.whl → 2.4.1__cp310-cp310-macosx_10_9_universal2.whl

{QuLab-2.3.6.dist-info → QuLab-2.4.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: QuLab
-Version: 2.3.6
+Version: 2.4.1
 Summary: contral instruments and manage data
 Author-email: feihoo87 <feihoo87@gmail.com>
 Maintainer-email: feihoo87 <feihoo87@gmail.com>
@@ -24,23 +24,26 @@ Classifier: Programming Language :: Python :: 3.12
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: blinker >=1.4
-Requires-Dist: click >=7.1.2
-Requires-Dist: dill >=0.3.6
-Requires-Dist: GitPython >=3.1.14
-Requires-Dist: ipython >=7.4.0
-Requires-Dist: ipywidgets >=7.4.2
-Requires-Dist: loguru >=0.7.2
-Requires-Dist: matplotlib >=3.7.2
-Requires-Dist: nevergrad >=1.0.2
-Requires-Dist: numpy >=1.13.3
-Requires-Dist: ply >=3.11
-Requires-Dist: pyzmq >=25.1.0
-Requires-Dist: scipy >=1.0.0
-Requires-Dist: watchdog >=4.0.0
+Requires-Dist: blinker>=1.4
+Requires-Dist: click>=7.1.2
+Requires-Dist: dill>=0.3.6
+Requires-Dist: GitPython>=3.1.14
+Requires-Dist: ipython>=7.4.0
+Requires-Dist: ipywidgets>=7.4.2
+Requires-Dist: loguru>=0.7.2
+Requires-Dist: matplotlib>=3.7.2
+Requires-Dist: msgpack>=1.0.5
+Requires-Dist: nevergrad>=1.0.2
+Requires-Dist: numpy>=1.13.3
+Requires-Dist: ply>=3.11
+Requires-Dist: pyzmq>=25.1.0
+Requires-Dist: scipy>=1.0.0
+Requires-Dist: scikit-optimize>=0.9.0
+Requires-Dist: SQLAlchemy>=2.0.19
+Requires-Dist: watchdog>=4.0.0
+Requires-Dist: waveforms>=1.9.4
 Provides-Extra: full
-Requires-Dist: SQLAlchemy >=2.0.19 ; extra == 'full'
-Requires-Dist: uvloop >=0.19.0 ; extra == 'full'
+Requires-Dist: uvloop>=0.19.0; extra == "full"
 
 # QuLab
 [![View build status](https://travis-ci.org/feihoo87/QuLab.svg?branch=master)](https://travis-ci.org/feihoo87/QuLab)

{QuLab-2.3.6.dist-info → QuLab-2.4.1.dist-info}/RECORD

@@ -1,7 +1,15 @@
 qulab/__init__.py,sha256=P-Mx2p4TVmL91SoxoeXcj8Qm0x4xUf5Q_FLk0Yc_gIQ,138
-qulab/__main__.py,sha256=ZC1NKaoxKyy60DaCfB8vYnB1z3RXQ2j8E1sRZ4A8sXE,428
-qulab/fun.cpython-310-darwin.so,sha256=XvwXGsOfn3ONbwMDYo4dcO4KOOTMBORrvTOYoCz0I3o,159632
-qulab/version.py,sha256=ZYW5EwlmyblvQtaORgk_8_vizsHXlkdmJ__EGWdTMAY,21
+qulab/__main__.py,sha256=V5jIyfuCSi5dI6jvqgH_BpXG0URd6bgneDdVCM1dGSA,545
+qulab/dicttree.py,sha256=tRRMpGZYVOLw0TEByE3_2Ss8FdOmzuGL9e1DWbs8qoY,13684
+qulab/fun.cpython-310-darwin.so,sha256=D8D2k4BdfCbo-CLgm27GMTgx-snj3Qtrc-xmkmDm-uc,126864
+qulab/version.py,sha256=CqVHPUFnrZpBglKOmFBRr4nAIcRkzVmVVYwtVbAYLgM,21
+qulab/executor/__init__.py,sha256=LosPzOMaljSZY1thy_Fxtbrgq7uubJszMABEB7oM7tU,101
+qulab/executor/__main__.py,sha256=r4hRH0i4C83xcB_BVXXNNSnUkV-cPx2pGHj9E8h3l8M,2282
+qulab/executor/load.py,sha256=jZHkEzFF8ufFAIajkRDKmHYYJxbxI3RcEbAFIbl9VQ0,6208
+qulab/executor/schedule.py,sha256=u3S8b6AwfdXyM_kAfrWr9zCi15qS40nRRdFEVyzJMmI,8503
+qulab/executor/storage.py,sha256=uYT2GtNEVX-lwICvDFBRH4hanBnPGue1lu2srvqYI_A,4518
+qulab/executor/transform.py,sha256=Sy1ZmzkaP4RhUMempYxcIRjuzTxbC9UikUMBKuoVleE,2148
+qulab/executor/utils.py,sha256=vrwk2fAfSp3YLVZfrYPvxsVPpeuE2n-4G2Ae0eqdT4s,3080
 qulab/monitor/__init__.py,sha256=nTHelnDpxRS_fl_B38TsN0njgq8eVTEz9IAnN3NbDlM,42
 qulab/monitor/__main__.py,sha256=w3yUcqq195LzSnXTkQcuC1RSFRhy4oQ_PEBmucXguME,97
 qulab/monitor/config.py,sha256=fQ5JcsMApKc1UwANEnIvbDQZl8uYW0tle92SaYtX9lI,744
@@ -13,14 +21,14 @@ qulab/monitor/ploter.py,sha256=CbiIjmohgtwDDTVeGzhXEGVo3XjytMdhLwU9VUkg9vo,3601
 qulab/monitor/qt_compat.py,sha256=OK71_JSO_iyXjRIKHANmaK4Lx4bILUzmXI-mwKg3QeI,788
 qulab/monitor/toolbar.py,sha256=WEag6cxAtEsOLL14XvM7pSE56EA3MO188_JuprNjdBs,7948
 qulab/scan/__init__.py,sha256=ZX4WsvqYxvJeHLgGSrtJoAnVU94gxY7EHKMxYooMERg,130
-qulab/scan/curd.py,sha256=thq_qfi3qng3Zx-1uhNG64IQhGCuum_LR4MOKnS8cDI,6896
-qulab/scan/expression.py,sha256=ngWrP1o9CuYJ1gq5YHaV7EfxKIKUX7Gz6KG80E6XThY,20070
-qulab/scan/models.py,sha256=5Jpo25WGMWs0GtLzYLsWO61G3-FFYx5BHhBr2b6rOTE,17681
+qulab/scan/curd.py,sha256=ZcwO5SKO95OcDgpUPDHcK5FW_BrJbUzuBk71UG_pqnM,6888
+qulab/scan/expression.py,sha256=Yw2_ynDpKiLeyS5m53lURFtesLkzaF9PIyAWbW-LOr0,20176
+qulab/scan/models.py,sha256=JFofv-RH0gpS3--M6izXiQg7iGkS9a_em2DwhS5kTTk,17626
 qulab/scan/optimize.py,sha256=VT9TpuqDkG7FdJJkYy60r5Pfrmjvfu5i36Ru6XvIiTI,2561
 qulab/scan/query.py,sha256=-5uHMhXSyGovK1oy_uUbGVEbRFzaMBkP78ZMNfI3jD0,11809
 qulab/scan/record.py,sha256=yIHPANf6nuBXy8Igf-dMtGJ7wuFTLYlBaaAUc0AzwyU,21280
 qulab/scan/scan.py,sha256=iXvbnXLZvHa4v88MlYiZ_LYubEB7ZfbX7OiFTMhl_1o,39479
-qulab/scan/server.py,sha256=lb-FoGGLrTOi22f1iinimAqIJRhXJxMIJxkvdV7WiOs,19961
+qulab/scan/server.py,sha256=XVwr8EC1iFhSAmecFZPWvn7N2O5MT65oZCd56GxDdIg,20035
 qulab/scan/space.py,sha256=OQLepiNNP5TNYMHXeVFT59lL5n4soPmnMoMy_o9EHt0,6696
 qulab/scan/utils.py,sha256=SzJ_c4cLZJzERZr_CJO1_4juOxjfwCpU2K1mkc1PWGM,6124
 qulab/storage/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -46,9 +54,9 @@ qulab/sys/chat.py,sha256=DlFLP_gbVyL8fDUyad6Xu8sjQCZJauLIvF31mj5BtMs,22449
 qulab/sys/ipy_events.py,sha256=qvsqs7-CYQ-P4WtSe9UUZZ0tC88XxPMd9DM4LJALgEk,2889
 qulab/sys/progress.py,sha256=Tk1B96_1QrlI4yU0cyZlf2wVsF238DjQGqXJVG2j4t0,5350
 qulab/sys/device/__init__.py,sha256=bDqJrYQJx8YR4u_CYvJPpIBr6whP7pVnxnROTHk_yhA,149
-qulab/sys/device/basedevice.py,sha256=iqyX2SQLb7aRWNE5Uj2yHkFOLqVrX2I1N-xubTDB5tQ,6423
+qulab/sys/device/basedevice.py,sha256=wMI93Y3Qz0oWYartWIVKoYEoOnuEaz_GRq3Ucw6brBk,6475
 qulab/sys/device/loader.py,sha256=AL0rNF4UZ-CUHoF8FNtT_ZGLwySvz7SDPsKALaJS8po,2501
-qulab/sys/device/utils.py,sha256=H9TvMqHZABhFdIah4uT0x9FvQ6ZPwbvw-wCnWTy4rfo,1564
+qulab/sys/device/utils.py,sha256=4NG_OKMDRdVH8YKHNf6kVocevXf7bqyf1PiGctTF_oA,2314
 qulab/sys/drivers/FakeInstrument.py,sha256=kwIXN-dHmvGYBinmcCLxUQKm0ENiJpsMwgQIYNLDS2k,1867
 qulab/sys/drivers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 qulab/sys/net/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -64,6 +72,7 @@ qulab/sys/rpc/client.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 qulab/sys/rpc/exceptions.py,sha256=djK44hYVMixF2Y-lAXDGHlyyCmYGw7EJjB3I0ttejok,2567
 qulab/sys/rpc/msgpack.py,sha256=s9mbPIkQktO1FiSAuE6ymM_1w8rIERA0gMm5GQkT7z8,35327
 qulab/sys/rpc/msgpack.pyi,sha256=3dJgISPCTEBo65VaoGjcFkdLijPx6zJtKqcZiS9bcaE,1274
+qulab/sys/rpc/router.py,sha256=Q10UA0cL95PcrtYU0dpPsq3hLSN9IzFaL8XCpIBSqbk,941
 qulab/sys/rpc/rpc.py,sha256=9ZwzC79FgmbHXbO1Gjg4z0wZgHLDziTwVuS2aZpLJAk,11979
 qulab/sys/rpc/serialize.py,sha256=0SR1me02mao2JwWR3rdjUIcOzh1m1JFb7fLEaw_q-pE,3355
 qulab/sys/rpc/server.py,sha256=e3R0gwOHpLEkSp7Tb43FMSDvqSG-pjrkskdISKQRseE,713
@@ -73,14 +82,16 @@ qulab/sys/rpc/worker.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 qulab/sys/rpc/zmq_socket.py,sha256=2uc9MjCRUwWm6iPmi2VGnOYNf9yWFSUzEVYrx0jZvPU,8272
 qulab/visualization/__init__.py,sha256=26cuHt3QIJXUb3VaMxlJx3IQTOUVJFKlYBZr7WMP53M,6129
 qulab/visualization/__main__.py,sha256=9zKK3yZFy0leU40ou6BpRC1Fsetfc1gjjFzIZYIwP6Y,1639
-qulab/visualization/_autoplot.py,sha256=jddg40dX48Wd8G6NLFA_Kf7z1QxdrZBDS99Xx2GLMqs,14099
+qulab/visualization/_autoplot.py,sha256=31B7pn1pK19abpQDGYBU9a_27cDL87LBpx9vKqlcYAo,14165
+qulab/visualization/plot_circ.py,sha256=qZS3auNG4qIyUvC-ijTce17xJwGBvpRvPUqPEx64KUY,8759
 qulab/visualization/plot_layout.py,sha256=clNw9QjE_kVNpIIx2Ob4YhAz2fucPGMuzkoIrOJo_Y8,13533
-qulab/visualization/plot_seq.py,sha256=lphYF4VhkEdc_wWr1kFBwrx2yujkyFPFaJ3pjr61awI,2693
+qulab/visualization/plot_seq.py,sha256=UWTS6p9nfX_7B8ehcYo6UnSTUCjkBsNU9jiOeW2calY,6751
 qulab/visualization/qdat.py,sha256=ZeevBYWkzbww4xZnsjHhw7wRorJCBzbG0iEu-XQB4EA,5735
+qulab/visualization/rot3d.py,sha256=lMrEJlRLwYe6NMBlGkKYpp_V9CTipOAuDy6QW_cQK00,734
 qulab/visualization/widgets.py,sha256=6KkiTyQ8J-ei70LbPQZAK35wjktY47w2IveOa682ftA,3180
-QuLab-2.3.6.dist-info/LICENSE,sha256=PRzIKxZtpQcH7whTG6Egvzl1A0BvnSf30tmR2X2KrpA,1065
-QuLab-2.3.6.dist-info/METADATA,sha256=swiVtD-iwLzFtt1Aspniiz20EpamHzO5mpkz4mOq6FU,3633
-QuLab-2.3.6.dist-info/WHEEL,sha256=LLSyqktal3jZJhWNtlg7HaUJKl3AGKH2j3EL7wpWyD4,114
-QuLab-2.3.6.dist-info/entry_points.txt,sha256=ohBzutEnQimP_BZWiuXdSliu4QAYSHHcN0PZD8c7ZCY,46
-QuLab-2.3.6.dist-info/top_level.txt,sha256=3T886LbAsbvjonu_TDdmgxKYUn939BVTRPxPl9r4cEg,6
-QuLab-2.3.6.dist-info/RECORD,,
+QuLab-2.4.1.dist-info/LICENSE,sha256=PRzIKxZtpQcH7whTG6Egvzl1A0BvnSf30tmR2X2KrpA,1065
+QuLab-2.4.1.dist-info/METADATA,sha256=sLQ_7QutS5SAr4nKHWIk4wjJX4_fEZH9FI0gSOVfAq8,3698
+QuLab-2.4.1.dist-info/WHEEL,sha256=Yd3eJSBM2hj8W-ouaiMfFUwQYAS-D6P73Ob9yN5MZd0,114
+QuLab-2.4.1.dist-info/entry_points.txt,sha256=b0v1GXOwmxY-nCCsPN_rHZZvY9CtTbWqrGj8u1m8yHo,45
+QuLab-2.4.1.dist-info/top_level.txt,sha256=3T886LbAsbvjonu_TDdmgxKYUn939BVTRPxPl9r4cEg,6
+QuLab-2.4.1.dist-info/RECORD,,

{QuLab-2.3.6.dist-info → QuLab-2.4.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (71.0.0)
+Generator: setuptools (75.8.0)
 Root-Is-Purelib: false
 Tag: cp310-cp310-macosx_10_9_universal2
 

QuLab-2.4.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+qulab = qulab.__main__:cli

qulab/__main__.py

@@ -1,5 +1,6 @@
 import click
 
+from .executor.__main__ import create, maintain, run
 from .monitor.__main__ import main as monitor
 from .scan.server import server
 from .sys.net.cli import dht
@@ -7,20 +8,23 @@ from .visualization.__main__ import plot
 
 
 @click.group()
-def main():
+def cli():
     pass
 
 
-@main.command()
+@cli.command()
 def hello():
     """Print hello world."""
     click.echo('hello, world')
 
 
-main.add_command(monitor)
-main.add_command(plot)
-main.add_command(dht)
-main.add_command(server)
+cli.add_command(monitor)
+cli.add_command(plot)
+cli.add_command(dht)
+cli.add_command(server)
+cli.add_command(maintain)
+cli.add_command(run)
+cli.add_command(create)
 
 if __name__ == '__main__':
-    main()
+    cli()

qulab/dicttree.py

@@ -0,0 +1,511 @@
+import copy
+import math
+import operator
+import pickle
+import sys
+from typing import Any, Generator
+
+
+class Singleton(type):
+    _instances = {}
+
+    def __call__(cls, *args, **kwargs):
+        if cls not in cls._instances:
+            cls._instances[cls] = super(Singleton,
+                                        cls).__call__(*args, **kwargs)
+        return cls._instances[cls]
+
+
+class _SELF(metaclass=Singleton):
+    __slots__ = ()
+
+    def __repr__(self):
+        return "self"
+
+
+class _NOTSET(metaclass=Singleton):
+    __slots__ = ()
+
+    def __repr__(self):
+        return 'N/A'
+
+
+class _UNKNOW(metaclass=Singleton):
+    __slots__ = ()
+
+    def __repr__(self) -> str:
+        return "Unknow"
+
+
+class _DELETE(metaclass=Singleton):
+    __slots__ = ()
+
+    def __repr__(self):
+        return 'Delete'
+
+
+SELF = _SELF()
+NOTSET = _NOTSET()
+UNKNOW = _UNKNOW()
+DELETE = _DELETE()
+
+
+def flattenDictIter(d: dict,
+                    prefix: list = []
+                    ) -> Generator[tuple[str, Any], None, None]:
+    for k in d:
+        if isinstance(d[k], dict):
+            yield from flattenDictIter(d[k], prefix=[*prefix, k])
+        else:
+            yield '.'.join(prefix + [k]), d[k]
+
+
+def flattenDict(d: dict[str, Any]) -> dict[str, Any]:
+    return {k: v for k, v in flattenDictIter(d)}
+
+
+def foldDict(d: dict[str, Any]) -> dict[str, Any]:
+    ret = {}
+
+    for k, v in d.items():
+        keys = k.split('.')
+        d = ret
+        parent = None
+
+        for key in keys[:-1]:
+            if not isinstance(d, dict):
+                parent[0][parent[1]] = {SELF: d}
+                d = parent[0][parent[1]]
+            if key not in d:
+                d[key] = dict()
+            parent = d, key
+            d = d[key]
+        if not isinstance(d, dict):
+            parent[0][parent[1]] = {SELF: d}
+            d = parent[0][parent[1]]
+        if keys[-1] in d and isinstance(d[keys[-1]], dict):
+            d[keys[-1]][SELF] = v
+        else:
+            d[keys[-1]] = v
+    return ret
+
+
+class Update():
+    __slots__ = ('o', 'n')
+
+    def __init__(self, o, n):
+        self.o = o
+        self.n = n
+
+    def __repr__(self):
+        return f"Update: {self.o!r} ==> {self.n!r}"
+
+    def __eq__(self, o: object) -> bool:
+        return isinstance(o, Update) and self.n == o.n
+
+
+class Create():
+    __slots__ = ('n', 'replace')
+
+    def __init__(self, n, replace=False):
+        """
+        Create a new node
+
+        :param n: the new node
+        :param replace: if True, replace the node if it already exists
+        """
+        self.n = n
+        self.replace = replace
+
+    def __repr__(self):
+        if self.replace:
+            return f"Replace: {self.n!r}"
+        else:
+            return f"Create: {self.n!r}"
+
+    def __eq__(self, o: object) -> bool:
+        return isinstance(
+            o, Create) and self.n == o.n and self.replace == o.replace
+
+
+def _eq(a, b):
+    import numpy as np
+
+    if isinstance(a, np.ndarray):
+        return np.array_equal(a, np.asarray(b))
+
+    try:
+        return a == b
+    except:
+        pass
+    if isinstance(a, (list, tuple)):
+        return len(a) == len(b) and all(_eq(a[i], b[i]) for i in range(len(a)))
+    if isinstance(a, dict):
+        return set(a.keys()) == set(b.keys()) and all(
+            _eq(a[k], b[k]) for k in a)
+
+    try:
+        return pickle.dumps(a) == pickle.dumps(b)
+    except:
+        return False
+
+
+def diff(d1: dict, d2: dict) -> dict:
+    """
+    Compute the difference between two dictionaries
+
+    Args:
+        d1: the original dictionary
+        d2: the new dictionary
+
+    Returns:
+        a dictionary containing the difference between d1 and d2
+    """
+    ret = {}
+    for k in d2:
+        if k in d1:
+            if isinstance(d2[k], type(d1[k])) and _eq(d1[k], d2[k]):
+                pass
+            elif isinstance(d1[k], dict) and isinstance(d2[k], dict):
+                ret[k] = diff(d1[k], d2[k])
+            else:
+                ret[k] = Update(d1[k], d2[k])
+        else:
+            ret[k] = Create(d2[k])
+    for k in d1:
+        if k not in d2:
+            ret[k] = DELETE
+    return ret
+
+
+def patch(source, diff, in_place=False):
+    """
+    Patch a dictionary with a diff
+
+    Args:
+        source: the original dictionary
+        diff: the diff
+        in_place: if True, patch the source dictionary in place
+    
+    Returns:
+        the patched dictionary
+    """
+    if in_place:
+        ret = source
+    else:
+        ret = copy.copy(source)
+    for k, v in diff.items():
+        if isinstance(v, dict):
+            ret[k] = patch(source[k], v, in_place=in_place)
+        else:
+            if isinstance(v, Update):
+                ret[k] = v.n
+            elif isinstance(v, Create):
+                if v.replace or k not in ret:
+                    ret[k] = v.n
+                else:
+                    update_tree(ret[k], v.n)
+            elif v is DELETE:
+                del ret[k]
+            else:
+                raise ValueError(f"Unsupported patch: {v!r}")
+    return ret
+
+
+def merge(diff1, diff2, origin=None):
+    """
+    Merge two diffs
+
+    Args:
+        diff1: the first diff
+        diff2: the second diff
+        origin: the original dictionary
+
+    Returns:
+        the merged diff
+    """
+    if origin is not None:
+        updated = patch(patch(origin, diff1), diff2)
+        return diff(origin, updated)
+
+    ret = {}
+    for k, v in diff1.items():
+        if k in diff2:
+            v2 = diff2[k]
+            if isinstance(v, dict) and isinstance(v2, dict):
+                d = merge(v, v2)
+                if d:
+                    ret[k] = d
+            else:
+                if isinstance(v, Update) and isinstance(v2, Update):
+                    ret[k] = Update(v.o, v2.n)
+                elif isinstance(v, Create) and isinstance(v2, dict):
+                    ret[k] = Create(patch(copy.copy(v.n), v2, True))
+                elif isinstance(v, Create) and isinstance(v2, Update):
+                    ret[k] = Create(v2.n)
+                elif isinstance(v, Create) and v2 is DELETE:
+                    pass
+                elif v2 is DELETE:
+                    ret[k] = DELETE
+                elif v is DELETE and isinstance(v2, Create):
+                    if isinstance(v2.n, dict):
+                        ret[k] = Create(v2.n, replace=True)
+                    else:
+                        ret[k] = Update(UNKNOW, v2.n)
+                elif isinstance(v2, Create) and v2.replace:
+                    ret[k] = v2
+                else:
+                    raise ValueError(f"Unsupported merge: {v!r} {v2!r}")
+        else:
+            ret[k] = v
+    for k, v in diff2.items():
+        if k not in diff1:
+            ret[k] = v
+    return ret
+
+
+def print_diff(d, limit=None, offset=0, file=sys.stdout, ignores=None):
+    """
+    Print a diff
+
+    Args:
+        d: the diff
+        limit: the maximum number of lines to print
+        offset: the offset of the first line
+        file: the file to print to
+        ignores: ignore keys starting with this prefix
+    """
+    count = 0
+    for i, (k, v) in enumerate(flattenDictIter(d)):
+        if count >= offset:
+            if ignores is not None and k.startswith(ignores):
+                continue
+            print(f"{k:40}", v, file=file)
+            count += 1
+            if limit is not None and count >= limit:
+                break
+
+
+def update_tree(result, updates):
+    for k, v in updates.items():
+        if isinstance(v, dict):
+            if k not in result or not isinstance(result[k], dict):
+                result[k] = {}
+            update_tree(result[k], v)
+        else:
+            result[k] = v
+    return result
+
+
+def queryref_tree(q, keys, dct, prefix=[], chain=None):
+    q = q[1:]
+    if q.startswith('.'):
+        while q.startswith('.'):
+            keys.pop()
+            q = q[1:]
+        q = '.'.join(keys + [q])
+
+    if chain is None:
+        chain = [q]
+    elif q in chain:
+        raise KeyError(f'Circular reference: {chain+[q]}')
+
+    return query_tree(q, dct, prefix=prefix, eval=True, chain=chain + [q])
+
+
+def query_tree(q, dct, prefix=[], eval=True, chain=None):
+    ret = dct
+    keys = q.split('.')
+    for i, key in enumerate(keys):
+        if key not in ret:
+            return (NOTSET, '.'.join(prefix + keys[:i + 1]))
+        ret = ret[key]
+    if isinstance(ret, str) and eval:
+        if ret.startswith('$'):
+            return queryref_tree(ret, keys, dct, prefix=prefix, chain=chain)
+        elif ret.startswith('&'):
+            return eval_expr(ret[1:], Env(dct,
+                                          keys,
+                                          prefix=prefix,
+                                          chain=chain))
+    return ret
+
+
+class Env():
+
+    def __init__(self, dct=None, keys=None, prefix=[], chain=None):
+        self.dct = dct if dct is not None else {}
+        self.keys = keys if keys is not None else []
+        self.chain = chain
+        self.prefix = prefix
+
+    def get(self, name):
+        return queryref_tree(name[1:],
+                             self.keys,
+                             self.dct,
+                             prefix=self.prefix,
+                             chain=self.chain)
+
+
+internal_functions = {
+    '**': operator.pow,
+    '+': operator.add,
+    '-': operator.sub,
+    '*': operator.mul,
+    '/': operator.truediv,
+    '//': operator.floordiv,
+    '%': operator.mod,
+    '&': operator.and_,
+    '|': operator.or_,
+    '^': operator.xor,
+    '~': operator.invert,
+    '<<': operator.lshift,
+    '>>': operator.rshift,
+    'getitem': operator.getitem,
+    'contains': operator.contains,
+    'not': operator.not_,
+    'getattr': getattr,
+    'abs': abs,
+    'min': min,
+    'max': max,
+    'sum': sum,
+    'len': len,
+    'any': any,
+    'all': all,
+    'ord': ord,
+    'chr': chr,
+    'bin': bin,
+    'oct': oct,
+    'hex': hex,
+    'int': int,
+    'round': round,
+    'real': lambda x: x.real,
+    'imag': lambda x: x.imag,
+    'sqrt': math.sqrt,
+    'sin': math.sin,
+    'cos': math.cos,
+    'tan': math.tan,
+    'asin': math.asin,
+    'acos': math.acos,
+    'atan': math.atan,
+    'atan2': math.atan2,
+    'sinh': math.sinh,
+    'cosh': math.cosh,
+    'tanh': math.tanh,
+    'asinh': math.asinh,
+    'acosh': math.acosh,
+    'atanh': math.atanh,
+    'ceil': math.ceil,
+    'floor': math.floor,
+    'trunc': math.trunc,
+    'log10': math.log10,
+    'log': math.log,
+    'exp': math.exp,
+}
+
+
+def eval_expr(expression, env=None, functions=None):
+    from pyparsing import (Forward, Literal, ParseResults, Suppress, Word,
+                           alphanums, delimitedList, infixNotation, oneOf,
+                           opAssoc, pyparsing_common)
+    if functions is None:
+        functions = internal_functions
+
+    def lookup(name):
+        return env.get(name)
+
+    def apply(fun, *args):
+        return functions[fun](*args)
+
+    def eval_expr(t):
+        if not isinstance(t, ParseResults):
+            return t
+        if t[0] == '-' and len(t) == 2:
+            return -t[1]
+        return apply(t[1], t[0], t[2])
+
+    # Define pyparsing grammar
+    expr = Forward()
+
+    complex_ = (pyparsing_common.number +
+                'j').setParseAction(lambda s, l, t: complex(t[0]))
+    number = pyparsing_common.number | complex_
+
+    const = oneOf('pi e').setParseAction(lambda s, l, t: {
+        'pi': math.pi,
+        'e': math.e
+    }.get(t[0]))
+
+    variable = Word("$", alphanums +
+                    "._").setParseAction(lambda s, l, t: lookup(t[0]))
+
+    bracket = Suppress('(') + expr + Suppress(')')
+    bracket.setParseAction(lambda s, l, t: t[0])
+
+    operand = const | variable | number | bracket
+
+    func = pyparsing_common.identifier
+    func_call = func + Suppress("(") + delimitedList(expr) + Suppress(")")
+    func_call.setParseAction(lambda s, l, t: apply(t[0], *t[1:]))
+
+    term = operand | func_call
+
+    expr << infixNotation(term, [
+        (Literal('**'), 2, opAssoc.RIGHT),
+        (Literal('~'), 1, opAssoc.RIGHT),
+        (Literal('-'), 1, opAssoc.RIGHT),
+        (oneOf('* / // %'), 2, opAssoc.LEFT),
+        (oneOf('+ -'), 2, opAssoc.LEFT),
+        (oneOf('>> <<'), 2, opAssoc.LEFT),
+        (Literal('&'), 2, opAssoc.LEFT),
+        (Literal('^'), 2, opAssoc.LEFT),
+        (Literal('|'), 2, opAssoc.LEFT),
+    ])
+
+    expr.setParseAction(lambda s, l, t: eval_expr(t[0]))
+
+    parsed = expr.parseString(expression, parseAll=True)
+    return parsed[0]
+
+
+def sorted_tree(dct, *, keys=None):
+    if keys is None or callable(keys):
+        key = keys
+    elif isinstance(keys, list):
+        key = keys[0]
+        if len(keys) > 1:
+            keys = keys[1:]
+        else:
+            keys = None
+    elif (isinstance(keys, tuple) and len(keys) == 2
+          and isinstance(keys[1], dict)):
+        key = keys[0]
+        keys = keys[1]
+    else:
+        raise Exception(f"Unsupported keys: {keys!r}")
+
+    if isinstance(dct, dict):
+        if isinstance(keys, dict):
+            default = keys.get('default', None)
+            return {
+                k: sorted_tree(dct[k], keys=keys.get(k, default))
+                for k in sorted(dct.keys(), key=key)
+            }
+        else:
+            return {
+                k: sorted_tree(dct[k], keys=keys)
+                for k in sorted(dct.keys(), key=key)
+            }
+    elif isinstance(dct, set):
+        if isinstance(keys, dict):
+            default = keys.get('default', None)
+            return set([
+                sorted_tree(v, keys=keys.get(v, default))
+                for v in sorted(list(dct), key=key)
+            ])
+        else:
+            return set([
+                sorted_tree(v, keys=keys) for v in sorted(list(dct), key=key)
+            ])
+    else:
+        return dct