QuLab 2.9.2__tar.gz → 2.9.3__tar.gz

{qulab-2.9.2 → qulab-2.9.3}/PKG-INFO

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

{qulab-2.9.2 → qulab-2.9.3}/QuLab.egg-info/PKG-INFO

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

{qulab-2.9.2 → qulab-2.9.3}/qulab/executor/load.py

@@ -421,14 +421,10 @@ def _load_workflow_list(workflow, lst, code_path):
     for i, n in enumerate(lst):
         try:
             ret.append(load_workflow(n, code_path, mtime=workflow.__mtime__))
-        except TemplateKeyError:
-            raise TemplateKeyError(
-                f"Workflow {workflow.__workflow_id__} missing key in {i}th {n[0]} dependent mapping."
-            )
-        except TemplateTypeError:
-            raise TemplateTypeError(
-                f"Workflow {workflow.__workflow_id__} type error in {i}th {n[0]} dependent mapping."
-            )
+        except TemplateKeyError as e:
+            msg, *_ = e.args
+            e.args = (f"Workflow {workflow.__workflow_id__} entry {i}: {msg}", )
+            raise e
     return ret
 
 
@@ -470,8 +466,7 @@ def get_entries(workflow: WorkflowType,
 
 def make_graph(workflow: WorkflowType, graph: dict, code_path: str | Path):
     if workflow.__workflow_id__ in graph:
-        raise graphlib.CycleError(
-            f"Workflow {workflow.__workflow_id__} has a circular dependency")
+        return graph
     graph[workflow.__workflow_id__] = []
 
     if hasattr(workflow, 'entries'):

{qulab-2.9.2 → qulab-2.9.3}/qulab/executor/template.py

@@ -77,16 +77,18 @@ class TemplateVarExtractor(ast.NodeVisitor):
             if not isinstance(arg, ast.Constant) or not isinstance(
                     arg.value, str):
                 raise SyntaxError(
-                    f"Argument of VAR function must be a string. {self.fname}:{node.lineno}"
+                    f"Argument of VAR function must be a string."
+                    f" {self.fname}:{node.lineno}"
                 )
             if len(node.args) != 1:
                 raise SyntaxError(
-                    f"VAR function only accept one argument. {self.fname}:{node.lineno}"
+                    f"VAR function only accept one argument."
+                    f" {self.fname}:{node.lineno}"
                 )
             default = _notset
             for k in node.keywords:
                 if k.arg == 'default':
-                    pass
+                    default = k.value
                     # if isinstance(k.value, ast.Constant):
                     #     # default = k.value.value
                     #     default = k.value
@@ -97,7 +99,8 @@ class TemplateVarExtractor(ast.NodeVisitor):
                     #     # )
                 else:
                     raise SyntaxError(
-                        f"VAR function only accept keyword argument 'default'. {self.fname}:{node.lineno}"
+                        f"VAR function only accept keyword argument 'default'."
+                        f" {self.fname}:{node.lineno}"
                     )
 
             if default is _notset:
@@ -107,7 +110,8 @@ class TemplateVarExtractor(ast.NodeVisitor):
                 #                          ctx=ast.Load())
                 if arg.value not in self.mapping:
                     raise TemplateKeyError(
-                        f"The variable '{arg.value}' is not provided in mapping. {self.fname}:{node.lineno}"
+                        f"The variable '{arg.value}' is not provided in mapping."
+                        f" {self.fname}:{node.lineno}"
                     )
                 self.replacements[(node.lineno, node.end_lineno,
                                    node.col_offset,
@@ -147,12 +151,13 @@ class TemplateVarExtractor(ast.NodeVisitor):
             for var_name in template.get_identifiers():
                 if var_name not in self.mapping:
                     raise TemplateKeyError(
-                        f"The variable '{var_name}' is not provided in mapping. {self.fname}:{current_lineno}"
-                    )
+                        f"The variable '{var_name}' is not provided in mapping."
+                        f" {self.fname}:{current_lineno}")
                 if not isinstance(self.mapping[var_name], str):
                     raise TemplateTypeError(
-                        f"Mapping value for '{var_name}' must be a string. {self.fname}:{current_lineno}"
-                    )
+                        f"Mapping value for '{var_name}' must be a string,"
+                        f" but got {type(self.mapping[var_name])}."
+                        f" {self.fname}:{current_lineno}")
                 self.str_variables.add(var_name)
                 start, stop = 0, len(line)
                 if current_lineno == lineno:

{qulab-2.9.2 → qulab-2.9.3}/qulab/scan/server.py

@@ -125,7 +125,8 @@ def get_record(session: Session, id: int, datapath: Path) -> Record:
         record = record_cache[id][1]
     clear_cache()
     logger.debug(f"update lru time for record cache: {id=}")
-    record_cache[id] = time.time(), record
+    if record:
+        record_cache[id] = time.time(), record
     return record
 
 

qulab-2.9.3/qulab/sys/__init__.py

@@ -0,0 +1,2 @@
+from .device import (BaseDevice, VisaDevice, action, create_device, delete,
+                     exclude, get, post, set)

{qulab-2.9.2 → qulab-2.9.3}/qulab/sys/device/basedevice.py

@@ -1,6 +1,7 @@
 import itertools
 import logging
 import re
+import string
 from collections import defaultdict
 from functools import partial
 from typing import Any, Callable, Literal, NamedTuple
@@ -87,7 +88,8 @@ def _add_action(attrs: dict, key: str, method: str, func: Callable, doc: dict,
                 matrix[arg] = attrs[arg]
     for values in itertools.product(*[matrix[arg] for arg in arguments]):
         kwds = dict(zip(arguments, values))
-        mapping[key.format(**kwds)] = partial(func, **kwds)
+        # mapping[key.format(**kwds)] = partial(func, **kwds)
+        mapping[string.Template(key).substitute(kwds)] = partial(func, **kwds)
 
 
 def _build_docs(mapping: dict, attrs: dict) -> str:
@@ -180,6 +182,8 @@ class BaseDevice(metaclass=DeviceMeta):
 
 class VisaDevice(BaseDevice):
 
+    error_query = 'SYST:ERR?'
+
     def open(self) -> None:
         import pyvisa
         kwds = self.options.copy()
@@ -188,6 +192,7 @@ class VisaDevice(BaseDevice):
         else:
             rm = pyvisa.ResourceManager()
         self.resource = rm.open_resource(self.address, **kwds)
+        self.errors = []
 
     def close(self) -> None:
         self.resource.close()
@@ -196,6 +201,15 @@ class VisaDevice(BaseDevice):
         super().reset()
         self.resource.write('*RST')
 
+    def check_error(self):
+        if self.error_query:
+            while True:
+                error = self.resource.query(self.error_query)
+                error_code = int(error.split(',')[0])
+                if error_code == 0:
+                    break
+                self.errors.append(error)
+
     @get('idn')
     def get_idn(self) -> str:
         """Get instrument identification."""
@@ -209,13 +223,9 @@ class VisaDevice(BaseDevice):
     @get('errors')
     def get_errors(self) -> list[str]:
         """Get error queue."""
-        errors = []
-        while True:
-            error = self.resource.query('SYST:ERR?')
-            error_code = int(error.split(',')[0])
-            if error_code == 0:
-                break
-            errors.append(error)
+        self.check_error()
+        errors = self.errors
+        self.errors = []
         return errors
 
     @set('timeout')

{qulab-2.9.2 → qulab-2.9.3}/qulab/sys/device/loader.py

@@ -79,7 +79,7 @@ def create_device(driver_name: str, *args, **kwds) -> BaseDevice:
             except:
                 pass
 
-        dev = create_device_from_module(f"waveforms.sys.drivers.{driver_name}",
+        dev = create_device_from_module(f"qulab.sys.drivers.{driver_name}",
                                         args, kwds)
         return dev
     except:

qulab-2.9.3/qulab/sys/drivers/FakeInstrument.py

@@ -0,0 +1,68 @@
+import numpy as np
+
+from qulab.sys import BaseDevice, exclude, get, set
+
+
+class Device(BaseDevice):
+
+    channel = [
+        'X1', 'X2', 'X3', 'X4', 'Y1', 'Y2', 'Y3', 'Y4', 'Z1', 'Z2', 'Z3', 'Z4',
+        'M1', 'M2'
+    ]
+
+    @get('IDN')
+    def get_idn(self) -> str:
+        return 'Fake Instrument'
+
+    @get('${channel_type}${channel_num}.SampleRate',
+         channel_type=['X', 'Y'],
+         channel_num=[1, 2, 3, 4])
+    def get_sample_rate_DDS(self, channel_type: str,
+                            channel_num: int) -> float:
+        return 6e9
+
+    @get('${channel}.SampleRate', channel=['Z1', 'Z2', 'Z3', 'Z4'])
+    def get_sample_rate_Z(self, channel: str) -> float:
+        return 2e9
+
+    @get('${channel}.SampleRate', channel=['M1', 'M2'])
+    def get_sample_rate_AD(self, channel: str) -> float:
+        return 1e9
+
+    @set('${channel}.Vpp', channel=exclude(['M1', 'M2']))
+    def set_voltage(self, value: float, channel: str) -> None:
+        self.log.info(f'Set {channel} Vpp to {value}')
+
+    # @get('${channel}.Vpp', channel=exclude(['M1', 'M2']))
+    # def get_voltage(self, channel: str, default=0.0) -> float:
+    #     return self._status.get(f'{channel}.Vpp', default)
+
+    @set('${channel}.Offset', channel=exclude(['M1', 'M2']))
+    def set_offset(
+        self,
+        value: float,
+        channel: str,
+    ) -> None:
+        self.log.info(f'Set {channel} offset to {value}')
+
+    # @get('${channel}.Offset', channel=exclude(['M1', 'M2']))
+    # def get_offset(self, channel: str, default=0.0) -> float:
+    #     return self._status.get(f'{channel}.Offset', default)
+
+    @set('${channel}.Waveform', channel=exclude(['M1', 'M2']))
+    def set_waveform(self, value, channel: str) -> None:
+        self.log.info(f'Set {channel} waveform to {value!r}')
+
+    # @get('${channel}.Waveform', channel=exclude(['M1', 'M2']))
+    # def get_waveform(self, channel: str, default=None) -> str:
+    #     return self._status.get(f'{channel}.Waveform', default)
+
+    @set('${channel}.Size', channel=['M1', 'M2'])
+    def set_size(self, value, channel: str) -> None:
+        self.log.info(f'Set {channel} size to {value!r}')
+
+    @get('${channel}.Trace', channel=['M1', 'M2'])
+    def get_random_data(self, channel: str) -> np.ndarray:
+        size = self._status.get(f'{channel}.Size', 1024)
+        shots = self._status.get(f'{channel}.Shots', 128)
+        return np.random.randn(shots, size)

{qulab-2.9.2 → qulab-2.9.3}/qulab/sys/net/nginx.py

@@ -6,6 +6,9 @@ from fastapi import FastAPI, Request
 from fastapi.responses import Response
 from pydantic import BaseModel
 
+NGINX_DIR = 'C:/Users/Administrator/Desktop/nginx/nginx-1.20.2'
+HOST_URL = 'https://systemq.baqis.ac.cn'
+
 db = {
     "n01": {
         "notebook_port": 1000,
@@ -28,7 +31,8 @@ db = {
 }
 
 
-def fmt_config(ip, notebook_port, codeserver_port, local_notebook_port, local_codeserver_port, page):
+def fmt_config(ip, notebook_port, codeserver_port, local_notebook_port,
+               local_codeserver_port, page):
     return """
 server {""" + f"""
     listen {notebook_port} ssl;
@@ -108,6 +112,7 @@ server {""" + f"""
 }
 """
 
+
 def fmt_page(notebook_url, codeserver_url):
     return """
 <!DOCTYPE html>
@@ -142,7 +147,7 @@ class Node(BaseModel):
 app = FastAPI()
 
 
-@app.post("/ping")
+@app.post("/auth")
 async def auth(request: Request, node: Node):
     try:
         assert node.name in db
@@ -156,34 +161,31 @@ async def auth(request: Request, node: Node):
         else:
             print("    CHANGE IP", db[node.name]['ip'], "===>", ip)
             db[node.name]['ip'] = ip
-        
+
         #ip = request.headers.get('x-real-ip')
         local_notebook_port = node.notebook_port
         local_codeserver_port = node.codeserver_port
         codeserver_path = quote_plus(node.codeserver_path)
 
-        codeserver_url = f"https://systemq.baqis.ac.cn:{codeserver_port}?tkn=lZBAQISFF532&folder={codeserver_path}"
-        notebook_url = f"https://systemq.baqis.ac.cn:{notebook_port}/tree"
+        codeserver_url = f"{HOST_URL}:{codeserver_port}?tkn=lZBAQISFF532&folder={codeserver_path}"
+        notebook_url = f"{HOST_URL}:{notebook_port}/tree"
 
         page = fmt_page(notebook_url, codeserver_url)
         page = ''.join(page.splitlines())
 
-        config = fmt_config(ip, notebook_port, codeserver_port, local_notebook_port, local_codeserver_port, page)
+        config = fmt_config(ip, notebook_port, codeserver_port,
+                            local_notebook_port, local_codeserver_port, page)
 
-        with open(
-                f"C:/Users/Administrator/Desktop/nginx/nginx-1.20.2/conf/servers/{node.name}.conf",
-                "w") as f:
+        with open(f"{NGINX_DIR}/conf/servers/{node.name}.conf", "w") as f:
             f.write(config)
 
         await asyncio.sleep(0.1)
-        
+
         cwd = os.getcwd()
 
-        os.chdir(r'C:\Users\Administrator\Desktop\nginx\nginx-1.20.2')
+        os.chdir(NGINX_DIR)
 
-        os.system(
-            r'C:\Users\Administrator\Desktop\nginx\nginx-1.20.2\nginx.exe -s reload'
-        )
+        os.system(f'{NGINX_DIR}/nginx.exe -s reload')
 
         os.chdir(cwd)
 

qulab-2.9.3/qulab/version.py

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

qulab-2.9.2/qulab/sys/drivers/FakeInstrument.py

@@ -1,52 +0,0 @@
-from waveforms.sys.device import BaseDevice, exclude, get, set
-
-
-class Device(BaseDevice):
-
-    channel = [
-        'X1', 'X2', 'X3', 'X4', 'Y1', 'Y2', 'Y3', 'Y4', 'Z1', 'Z2', 'Z3', 'Z4',
-        'M1', 'M2'
-    ]
-
-    @get('IDN')
-    def get_idn(self) -> str:
-        return 'Fake Instrument'
-
-    @set('{channel}.Vpp', channel=exclude(['M1', 'M2']))
-    def set_voltage(self, value: float, channel: str) -> None:
-        self.log.info(f'Set {channel} Vpp to {value}')
-
-    @get('{channel}.Vpp', channel=exclude(['M1', 'M2']))
-    def get_voltage(self, channel: str, default=0.0) -> float:
-        return self._status.get(f'{channel}.Vpp', default)
-
-    @set('{channel}.Offset', channel=exclude(['M1', 'M2']))
-    def set_frequency(
-        self,
-        value: float,
-        channel: str,
-    ) -> None:
-        self.log.info(f'Set {channel} offset to {value}')
-
-    @get('{channel}.Offset', channel=exclude(['M1', 'M2']))
-    def get_frequency(self, channel: str, default=0.0) -> float:
-        return self._status.get(f'{channel}.Offset', default)
-
-    @set('{channel}.Waveform', channel=exclude(['M1', 'M2']))
-    def set_waveform(self, value, channel: str) -> None:
-        self.log.info(f'Set {channel} waveform to {value!r}')
-
-    @get('{channel}.Waveform', channel=exclude(['M1', 'M2']))
-    def get_waveform(self, channel: str, default=None) -> str:
-        return self._status.get(f'{channel}.Waveform', default)
-
-    @set('{channel}.Size', channel=['M1', 'M2'])
-    def set_size(self, value, channel: str) -> None:
-        self.log.info(f'Set {channel} size to {value!r}')
-
-    @get('{channel}.Trace', channel=['M1', 'M2'])
-    def get_size(self, channel: str) -> str:
-        import numpy as np
-        size = self._status.get(f'{channel}.Size', 1024)
-        shots = self._status.get(f'{channel}.Shots', 128)
-        return np.random.randn(shots, size)

qulab-2.9.2/qulab/version.py

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