QuLab 2.1.4__tar.gz → 2.2.3__tar.gz

{qulab-2.1.4 → qulab-2.2.3}/PKG-INFO

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

{qulab-2.1.4 → qulab-2.2.3}/QuLab.egg-info/PKG-INFO

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

{qulab-2.1.4 → qulab-2.2.3}/qulab/scan/query.py

@@ -12,8 +12,8 @@ from sqlalchemy.orm import sessionmaker
 from qulab.sys.rpc.zmq_socket import ZMQContextManager
 
 from .record import Record
-from .server import get_local_record
 from .scan import default_server
+from .server import get_local_record
 
 
 def get_record(id, database=default_server) -> Record:
@@ -24,6 +24,8 @@ def get_record(id, database=default_server) -> Record:
                 'record_id': id
             })
             d = dill.loads(socket.recv_pyobj())
+            if isinstance(d, None):
+                raise ValueError(f'No record with id {id}')
             d.id = id
             d.database = database
             d._file = None

{qulab-2.1.4 → qulab-2.2.3}/qulab/scan/record.py

@@ -1,4 +1,6 @@
 import itertools
+import lzma
+import pickle
 import sys
 import uuid
 import zipfile
@@ -12,6 +14,7 @@ import zmq
 
 from qulab.sys.rpc.zmq_socket import ZMQContextManager
 
+from .curd import get_config
 from .space import OptimizeSpace, Space
 
 _not_given = object()
@@ -326,6 +329,28 @@ class Record():
     def axis(self):
         return self.description.get('axis', {})
 
+    def config(self, cls=dict, session=None, datapath=None):
+        config_id = self.description.get('config', None)
+        if config_id is None:
+            return None
+        if isinstance(config_id, dict):
+            return cls(config_id)
+        if self.is_remote_record():
+            with ZMQContextManager(zmq.DEALER,
+                                   connect=self.database) as socket:
+                socket.send_pyobj({
+                    'method': 'config_get',
+                    'config_id': config_id
+                })
+                buf = socket.recv_pyobj()
+                return cls(pickle.loads(lzma.decompress(buf)))
+        else:
+            assert session is not None, "session is required for local record"
+            assert datapath is not None, "datapath is required for local record"
+            config = get_config(session, config_id, base=datapath / 'objects')
+            session.commit()
+            return cls(config)
+
     def is_local_record(self):
         return not self.is_cache_record() and not self.is_remote_record()
 

{qulab-2.1.4 → qulab-2.2.3}/qulab/scan/scan.py

@@ -145,17 +145,6 @@ async def create_config(config: dict, database=default_server, socket=None):
         return await socket.recv_pyobj()
 
 
-async def get_config(config_id: int, database=default_server, socket=None):
-    async with ZMQContextManager(zmq.DEALER, connect=database,
-                                 socket=socket) as socket:
-        await socket.send_pyobj({
-            'method': 'config_get',
-            'config_id': config_id
-        })
-        buf = await socket.recv_pyobj()
-        return pickle.loads(lzma.decompress(buf))
-
-
 def task_uuid():
     return uuid.uuid3(__process_uuid, str(next(__task_counter)))
 
@@ -332,7 +321,9 @@ class Scan():
     async def _emit(self, current_level, step, position, variables: dict[str,
                                                                          Any]):
         for key, value in list(variables.items()):
-            if inspect.isawaitable(value) and not self.hiden(key):
+            if key.startswith('*'):
+                await _unpack(key, variables)
+            elif inspect.isawaitable(value) and not self.hiden(key):
                 variables[key] = await value
         if self._sock is not None:
             await self._sock.send_pyobj({
@@ -362,7 +353,8 @@ class Scan():
         self._hide_pattern_re = re.compile('|'.join(self.description['hiden']))
 
     def hiden(self, name: str) -> bool:
-        return bool(self._hide_pattern_re.match(name))
+        return bool(
+            self._hide_pattern_re.match(name)) and not name.startswith('*')
 
     async def _filter(self, variables: dict[str, Any], level: int = 0):
         try:
@@ -971,9 +963,15 @@ async def _iter_level(variables,
 
         variables.update(await call_many_functions(order, getters, variables))
 
+        if opts:
+            for key in list(variables.keys()):
+                if key.startswith('*'):
+                    await _unpack(key, variables)
+
         for name, opt in opts.items():
             opt_cfg = optimizers[name]
             args = [variables[n] for n in opt_cfg.dimensions.keys()]
+
             if name not in variables:
                 raise ValueError(f'{name} not in variables.')
             fun = variables[name]
@@ -1012,3 +1010,26 @@ async def call_many_functions(order: list[list[str]],
             results = await asyncio.gather(*coros)
             ret.update(dict(zip(waited, results)))
     return ret
+
+
+async def _unpack(key, variables):
+    x = variables[key]
+    if inspect.isawaitable(x):
+        x = await x
+    if key.startswith('**'):
+        assert isinstance(x, dict), f"Should promise a dict for `**` symbol."
+        if "{key}" in key:
+            for k, v in x.items():
+                variables[key[2:].format(key=k)] = v
+        else:
+            variables.update(x)
+    elif key.startswith('*'):
+        assert isinstance(
+            x, (list, tuple,
+                np.ndarray)), f"Should promise a list for `*` symbol."
+        for i, v in enumerate(x):
+            k = key[1:].format(i=i)
+            variables[k] = v
+    else:
+        return
+    del variables[key]

{qulab-2.1.4 → qulab-2.2.3}/qulab/scan/server.py

@@ -65,6 +65,8 @@ def flush_cache():
 
 def get_local_record(session: Session, id: int, datapath: Path) -> Record:
     record_in_db = session.get(RecordInDB, id)
+    if record_in_db is None:
+        return None
     record_in_db.atime = utcnow()
 
     if record_in_db.file.endswith('.zip'):
@@ -220,21 +222,33 @@ async def handle(session: Session, request: Request, datapath: Path):
             await reply(request, config.id)
         case 'submit':
             from .scan import Scan
+            finished = [(id, queried) for id, (task, queried) in pool.items()
+                        if not isinstance(task, int) and task.finished()]
+            for id, queried in finished:
+                if not queried:
+                    pool[id] = [pool[id].record.id, False]
+                else:
+                    pool.pop(id)
             description = dill.loads(msg['description'])
             task = Scan()
             task.description = description
             task.start()
-            pool[task.id] = task
+            pool[task.id] = [task, False]
             await reply(request, task.id)
         case 'get_record_id':
-            task = pool.get(msg['id'])
-            for _ in range(10):
-                if task.record:
-                    await reply(request, task.record.id)
-                    break
-                await asyncio.sleep(1)
+            task, queried = pool.get(msg['id'])
+            if isinstance(task, int):
+                await reply(request, task)
+                pool.pop(msg['id'])
             else:
-                await reply(request, None)
+                for _ in range(10):
+                    if task.record:
+                        await reply(request, task.record.id)
+                        pool[msg['id']] = [task, True]
+                        break
+                    await asyncio.sleep(1)
+                else:
+                    await reply(request, None)
         case _:
             logger.error(f"Unknown method: {msg['method']}")
 

{qulab-2.1.4 → qulab-2.2.3}/qulab/scan/space.py

@@ -23,11 +23,11 @@ class Space():
         return len(self.toarray())
 
     @classmethod
-    def fromarray(cls, array):
-        if isinstance(array, Space):
-            return array
-        if isinstance(array, (list, tuple)):
-            array = np.array(array)
+    def fromarray(cls, space):
+        if isinstance(space, Space):
+            return space
+        if isinstance(space, (list, tuple)):
+            array = np.array(space)
         try:
             a = np.linspace(array[0], array[-1], len(array), dtype=array.dtype)
             if np.allclose(a, array):
@@ -81,7 +81,7 @@ class Space():
                            dtype=array.dtype)
         except:
             pass
-        return array
+        return space
 
     def toarray(self):
         return getattr(np, self.function)(*self.args, **self.kwds)

qulab-2.2.3/qulab/version.py

@@ -0,0 +1 @@
+__version__ = "2.2.3"

qulab-2.1.4/qulab/version.py

@@ -1 +0,0 @@
-__version__ = "2.1.4"