QuLab 2.2.7__cp312-cp312-macosx_10_9_universal2.whl → 2.3.0__cp312-cp312-macosx_10_9_universal2.whl

{QuLab-2.2.7.dist-info → QuLab-2.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: QuLab
-Version: 2.2.7
+Version: 2.3.0
 Summary: contral instruments and manage data
 Author-email: feihoo87 <feihoo87@gmail.com>
 Maintainer-email: feihoo87 <feihoo87@gmail.com>

{QuLab-2.2.7.dist-info → QuLab-2.3.0.dist-info}/RECORD

@@ -1,7 +1,7 @@
 qulab/__init__.py,sha256=P-Mx2p4TVmL91SoxoeXcj8Qm0x4xUf5Q_FLk0Yc_gIQ,138
 qulab/__main__.py,sha256=ZC1NKaoxKyy60DaCfB8vYnB1z3RXQ2j8E1sRZ4A8sXE,428
-qulab/fun.cpython-312-darwin.so,sha256=bK6YBpg8BHy3YmH1ak7NVoXnaF1HMAXTsvevATS9aHQ,159632
-qulab/version.py,sha256=I501tBgxLlOMpveUyk065aIcjgpxqCi7zjY3gqoar7c,21
+qulab/fun.cpython-312-darwin.so,sha256=JVHBI8lJzKnWDQrrte1tgnQMgtZJCl-CHbDnN1qad6s,159632
+qulab/version.py,sha256=GxSenfTTbLiVCmY5yEHjwuV-eKudBrOQ2NqIY4Qj64g,21
 qulab/monitor/__init__.py,sha256=nTHelnDpxRS_fl_B38TsN0njgq8eVTEz9IAnN3NbDlM,42
 qulab/monitor/__main__.py,sha256=w3yUcqq195LzSnXTkQcuC1RSFRhy4oQ_PEBmucXguME,97
 qulab/monitor/config.py,sha256=fQ5JcsMApKc1UwANEnIvbDQZl8uYW0tle92SaYtX9lI,744
@@ -14,14 +14,14 @@ qulab/monitor/qt_compat.py,sha256=OK71_JSO_iyXjRIKHANmaK4Lx4bILUzmXI-mwKg3QeI,78
 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=-aTYbjFQNI1mwOcoSBztqhKfGJpu_n4a1QnWro_xnTU,15694
+qulab/scan/expression.py,sha256=JsJ00qK05QVDAgz-husRuov7hKg8nW75rsTwLG8RH7Q,15843
 qulab/scan/models.py,sha256=5Jpo25WGMWs0GtLzYLsWO61G3-FFYx5BHhBr2b6rOTE,17681
-qulab/scan/optimize.py,sha256=vErjRTCtn2MwMF5Xyhs1P4gHF2IFHv_EqxsUvH_4y7k,2287
+qulab/scan/optimize.py,sha256=jYceGazEabuwYqmZE8P6Nnq_KsLyUP0p-p88VbbJLhM,2559
 qulab/scan/query.py,sha256=-5uHMhXSyGovK1oy_uUbGVEbRFzaMBkP78ZMNfI3jD0,11809
 qulab/scan/record.py,sha256=-FL9JMgfhvkT0q7dhJJXbjXOrOkTIk2J9oPmxP6psuA,21070
-qulab/scan/scan.py,sha256=KRCoq0ezqwIQlOifUAk9hUR-G-ryywUwEwP__rLMdPo,36499
-qulab/scan/server.py,sha256=6sWOx6xScz0CDMEexk9KYJ5nugneL9F45yeYQNIT7qM,14184
-qulab/scan/space.py,sha256=jDmFY2FcYe-Qcp16YBhAEdTKibOAsHQUnpDrpcPhvzg,5279
+qulab/scan/scan.py,sha256=GXjx5gDT2L7S2H_opdFl9fEEJNsHi2RlwJpcbAY4aKg,37837
+qulab/scan/server.py,sha256=ZT-J447xuLSpmbTNm5dNIz8_CXKOow66_bjkFNGh_vI,14274
+qulab/scan/space.py,sha256=tmTMrLzUwm-NiXDQyJsr--D6Gj8GbF9XQx--o1QpQzE,6092
 qulab/scan/utils.py,sha256=Pg_tCf3SUKTiPSBqb6Enkgx4bAyQJAkDGe9uYys1xVU,3613
 qulab/storage/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 qulab/storage/__main__.py,sha256=3emxxRry8BB0m8hUZvJ_oBqkPy7ksV7flHB_KEDXZuI,1692
@@ -78,9 +78,9 @@ qulab/visualization/plot_layout.py,sha256=clNw9QjE_kVNpIIx2Ob4YhAz2fucPGMuzkoIrO
 qulab/visualization/plot_seq.py,sha256=lphYF4VhkEdc_wWr1kFBwrx2yujkyFPFaJ3pjr61awI,2693
 qulab/visualization/qdat.py,sha256=ZeevBYWkzbww4xZnsjHhw7wRorJCBzbG0iEu-XQB4EA,5735
 qulab/visualization/widgets.py,sha256=6KkiTyQ8J-ei70LbPQZAK35wjktY47w2IveOa682ftA,3180
-QuLab-2.2.7.dist-info/LICENSE,sha256=PRzIKxZtpQcH7whTG6Egvzl1A0BvnSf30tmR2X2KrpA,1065
-QuLab-2.2.7.dist-info/METADATA,sha256=aP8Msk6d2Qyve2m5nVGNn8N3CniIqSdeqTbKS-8PqIo,3510
-QuLab-2.2.7.dist-info/WHEEL,sha256=aK27B_a3TQKBFhN_ATCfuFR4pBRqHlzwr7HpZ6iA79M,115
-QuLab-2.2.7.dist-info/entry_points.txt,sha256=ohBzutEnQimP_BZWiuXdSliu4QAYSHHcN0PZD8c7ZCY,46
-QuLab-2.2.7.dist-info/top_level.txt,sha256=3T886LbAsbvjonu_TDdmgxKYUn939BVTRPxPl9r4cEg,6
-QuLab-2.2.7.dist-info/RECORD,,
+QuLab-2.3.0.dist-info/LICENSE,sha256=PRzIKxZtpQcH7whTG6Egvzl1A0BvnSf30tmR2X2KrpA,1065
+QuLab-2.3.0.dist-info/METADATA,sha256=FB6pFPfzfkG_vsOZXBQhdl-lGrsSGXsAPAjOiaT6YfI,3510
+QuLab-2.3.0.dist-info/WHEEL,sha256=aK27B_a3TQKBFhN_ATCfuFR4pBRqHlzwr7HpZ6iA79M,115
+QuLab-2.3.0.dist-info/entry_points.txt,sha256=ohBzutEnQimP_BZWiuXdSliu4QAYSHHcN0PZD8c7ZCY,46
+QuLab-2.3.0.dist-info/top_level.txt,sha256=3T886LbAsbvjonu_TDdmgxKYUn939BVTRPxPl9r4cEg,6
+QuLab-2.3.0.dist-info/RECORD,,

qulab/scan/expression.py

@@ -284,6 +284,9 @@ class Expression():
         return ObjectMethod(self, '__getitem__', other)
 
     def __getattr__(self, other):
+        if isinstance(other, str):
+            if other.startswith('_') or other in self.__dict__:
+                return super().__getattr__(other)
         if isinstance(other, Expression):
             other = other.eval(_default_env)
         return ObjectMethod(self, '__getattr__', other)

qulab/scan/optimize.py

@@ -37,6 +37,12 @@ class NgOptimizer():
                            self.config['method'])(self.instrum,
                                                   budget=self.config['budget'])
 
+    def suggest(self, *suggested):
+        suggested = [
+            space.transform(x) for x, space in zip(suggested, self.dimensions)
+        ]
+        self.opt.suggest(*suggested)
+
     def ask(self):
         tmp = self.opt.ask()
         return [
@@ -47,15 +53,16 @@ class NgOptimizer():
     def tell(self, suggested: Sequence, value: Any):
         self._all_x.append(suggested)
         self._all_y.append(value)
-        suggested = [
+        suggested = tuple([
             space.transform(x) for x, space in zip(suggested, self.dimensions)
-        ]
-        self.opt.suggest(*suggested)
-        x = self.opt.ask()
+        ])
+        # self.opt.suggest(*suggested)
+        # x = self.opt.ask()
+        x = self.instrum.spawn_child(new_value=(suggested, {}))
         self.opt.tell(x, value)
 
     def get_result(self, history: bool = False) -> OptimizeResult:
-        recommendation = self.opt.recommend()
+        recommendation = self.opt.provide_recommendation()
         ret = OptimizeResult({
             'x': [
                 space.inverse_transform(x)

qulab/scan/scan.py

@@ -226,10 +226,11 @@ class Scan():
                  max_workers: int = 4,
                  max_promise: int = 100,
                  max_message: int = 1000,
+                 config: dict | None = None,
                  mixin=None):
         self.id = task_uuid()
         self.record = None
-        self.config = None
+        self.config = {} if config is None else copy.deepcopy(config)
         self.description = {
             'app': app,
             'tags': tags,
@@ -250,7 +251,7 @@ class Scan():
             'filters': {},
             'total': {},
             'database': database,
-            'hiden': ['self', r'^__.*', r'.*__$'],
+            'hiden': ['self', 'config', r'^__.*', r'.*__$'],
             'entry': {
                 'system': get_system_info(),
                 'env': {},
@@ -392,7 +393,10 @@ class Scan():
         if name in self.description['consts']:
             return self.description['consts'][name]
         else:
-            return Symbol(name)
+            try:
+                return self._query_config(name)
+            except:
+                return Symbol(name)
 
     def _add_search_space(self, name: str, level: int, space):
         if level not in self.description['loops']:
@@ -402,6 +406,8 @@ class Scan():
     def add_depends(self, name: str, depends: list[str]):
         if isinstance(depends, str):
             depends = [depends]
+        if 'self' in depends:
+            depends.append('config')
         if name not in self.description['dependents']:
             self.description['dependents'][name] = set()
         self.description['dependents'][name].update(depends)
@@ -448,6 +454,9 @@ class Scan():
                 pass
             self.description['consts'][name] = value
 
+        if '.' in name:
+            self.add_depends('config', [name])
+
         if ',' in name:
             for key in name.split(','):
                 if not key.startswith('*'):
@@ -472,6 +481,8 @@ class Scan():
         elif isinstance(space, OptimizeSpace):
             space.name = name
             space.optimizer.dimensions[name] = space.space
+            if space.suggestions:
+                space.optimizer.suggestions[name] = space.suggestions
             self._add_search_space(name, space.optimizer.level, space)
             self.add_depends(space.optimizer.name, [name])
         else:
@@ -486,6 +497,8 @@ class Scan():
                 self.add_depends(name, space.symbols())
         if setter:
             self.description['setters'][name] = setter
+        if '.' in name:
+            self.add_depends('config', [name])
 
     def trace(self,
               name: str,
@@ -535,6 +548,28 @@ class Scan():
             self.description['getters'][name] = getter
         return opt
 
+    def _synchronize_config(self):
+        for key, value in self.variables.items():
+            if '.' in key:
+                d = self.config
+                ks = key.split('.')
+                if not ks:
+                    continue
+                for k in ks[:-1]:
+                    if k in d:
+                        d = d[k]
+                    else:
+                        d[k] = {}
+                        d = d[k]
+                d[ks[-1]] = value
+        return self.config
+
+    def _query_config(self, key):
+        d = self.config
+        for k in key.split('.'):
+            d = d[k]
+        return d
+
     async def _update_progress(self):
         while True:
             task = await self._prm_queue.get()
@@ -549,17 +584,6 @@ class Scan():
 
     async def run(self):
         assymbly(self.description)
-        if self.config:
-            self.description['config'] = await create_config(
-                self.config, self.description['database'], self._sock)
-        if current_notebook() is None:
-            await create_notebook('untitle', self.description['database'],
-                                  self._sock)
-        cell_id = await save_input_cells(current_notebook(),
-                                         self.description['entry']['scripts'],
-                                         self.description['database'],
-                                         self._sock)
-        self.description['entry']['scripts'] = cell_id
         if isinstance(
                 self.description['database'],
                 str) and self.description['database'].startswith("tcp://"):
@@ -567,15 +591,28 @@ class Scan():
                                          connect=self.description['database'],
                                          socket=self._sock) as socket:
                 self._sock = socket
+                if self.config:
+                    self.description['config'] = await create_config(
+                        self.config, self.description['database'], self._sock)
+                if current_notebook() is None:
+                    await create_notebook('untitle',
+                                          self.description['database'],
+                                          self._sock)
+                cell_id = await save_input_cells(
+                    current_notebook(), self.description['entry']['scripts'],
+                    self.description['database'], self._sock)
+                self.description['entry']['scripts'] = cell_id
                 await self._run()
         else:
+            if self.config:
+                self.description['config'] = copy.deepcopy(self.config)
             await self._run()
 
     async def _run(self):
         send_msg_task = asyncio.create_task(self._send_msg())
         update_progress_task = asyncio.create_task(self._update_progress())
 
-        self._variables = {'self': self}
+        self._variables = {'self': self, 'config': self.config}
 
         consts = {}
         for k, v in self.description['consts'].items():
@@ -671,8 +708,10 @@ class Scan():
                 self.variables,
                 self.description['loops'].get(self.current_level, []),
                 self.description['order'].get(self.current_level, []),
-                self.description['functions'], self.description['optimizers'],
-                self.description['setters'], self.description['getters']):
+                self.description['functions']
+                | {'config': self._synchronize_config},
+                self.description['optimizers'], self.description['setters'],
+                self.description['getters']):
             self._current_level += 1
             if await self._filter(variables, self.current_level - 1):
                 yield variables

qulab/scan/server.py

@@ -160,8 +160,7 @@ async def handle(session: Session, request: Request, datapath: Path):
             else:
                 iter_id = uuid.uuid3(namespace, str(time.time_ns())).bytes
                 record = get_record(session, msg['record_id'], datapath)
-                bufferlist = record.get(msg['key'],
-                                        buffer_to_array=False)
+                bufferlist = record.get(msg['key'], buffer_to_array=False)
                 if msg['slice']:
                     bufferlist._slice = msg['slice']
                 it = bufferlist.iter()
@@ -329,7 +328,11 @@ async def serv(port,
             while True:
                 identity, msg = await sock.recv_multipart()
                 received += len(msg)
-                req = Request(sock, identity, msg)
+                try:
+                    req = Request(sock, identity, msg)
+                except:
+                    logger.exception('bad request')
+                    continue
                 asyncio.create_task(
                     handle_with_timeout(session, req, datapath, timeout=60.0))
                 if received > buffer_size or time.time(

qulab/scan/space.py

@@ -1,3 +1,4 @@
+import itertools
 from typing import Type
 
 import numpy as np
@@ -103,10 +104,14 @@ def geomspace(start, stop, num=50, endpoint=True):
 
 class OptimizeSpace():
 
-    def __init__(self, optimizer: 'Optimizer', space):
+    def __init__(self, optimizer: 'Optimizer', space, suggestions=None):
         self.optimizer = optimizer
         self.space = space
         self.name = None
+        if suggestions is not None and not isinstance(
+                suggestions, (list, tuple, np.ndarray)):
+            suggestions = [suggestions]
+        self.suggestions = suggestions
 
     def __len__(self):
         return self.optimizer.maxiter
@@ -130,39 +135,58 @@ class Optimizer():
         self.level = level
         self.kwds = kwds
         self.minimize = minimize
+        self.suggestions = {}
 
     def create(self):
-        return self.method(list(self.dimensions.values()), **self.kwds)
+        opt = self.method(list(self.dimensions.values()), **self.kwds)
+
+        def rvs(space):
+            while True:
+                yield space.rvs()[0]
+
+        if self.suggestions:
+            for suggestion in zip(*[
+                    self.suggestions.get(key, rvs(space))
+                    for key, space in self.dimensions.items()
+            ]):
+                opt.suggest(*suggestion)
+        return opt
 
     def Categorical(self,
                     categories,
                     prior=None,
                     transform=None,
-                    name=None) -> OptimizeSpace:
+                    name=None,
+                    suggestions=None) -> OptimizeSpace:
         return OptimizeSpace(self,
-                             Categorical(categories, prior, transform, name))
+                             Categorical(categories, prior, transform, name),
+                             suggestions)
 
     def Integer(self,
                 low,
                 high,
                 prior="uniform",
                 base=10,
-                transform=None,
+                transform="normalize",
                 name=None,
-                dtype=np.int64) -> OptimizeSpace:
+                dtype=np.int64,
+                suggestions=None) -> OptimizeSpace:
         return OptimizeSpace(
-            self, Integer(low, high, prior, base, transform, name, dtype))
+            self, Integer(low, high, prior, base, transform, name, dtype),
+            suggestions)
 
     def Real(self,
              low,
              high,
              prior="uniform",
              base=10,
-             transform=None,
+             transform="normalize",
              name=None,
-             dtype=float) -> OptimizeSpace:
+             dtype=float,
+             suggestions=None) -> OptimizeSpace:
         return OptimizeSpace(
-            self, Real(low, high, prior, base, transform, name, dtype))
+            self, Real(low, high, prior, base, transform, name, dtype),
+            suggestions)
 
     def __getstate__(self) -> dict:
         state = self.__dict__.copy()

qulab/version.py

@@ -1 +1 @@
-__version__ = "2.2.7"
+__version__ = "2.3.0"