QuLab 2.1.2__tar.gz → 2.1.4__tar.gz

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

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

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

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

{qulab-2.1.2 → qulab-2.1.4}/QuLab.egg-info/SOURCES.txt

@@ -29,7 +29,6 @@ qulab/scan/models.py
 qulab/scan/optimize.py
 qulab/scan/query.py
 qulab/scan/record.py
-qulab/scan/recorder.py
 qulab/scan/scan.py
 qulab/scan/server.py
 qulab/scan/space.py

{qulab-2.1.2 → qulab-2.1.4}/qulab/__main__.py

@@ -1,7 +1,6 @@
 import click
 
 from .monitor.__main__ import main as monitor
-from .scan.recorder import record
 from .scan.server import server
 from .sys.net.cli import dht
 from .visualization.__main__ import plot
@@ -21,7 +20,6 @@ def hello():
 main.add_command(monitor)
 main.add_command(plot)
 main.add_command(dht)
-main.add_command(record)
 main.add_command(server)
 
 if __name__ == '__main__':

{qulab-2.1.2 → qulab-2.1.4}/qulab/scan/curd.py

@@ -1,4 +1,7 @@
+import lzma
+import pickle
 from datetime import date, datetime, timezone
+from pathlib import Path
 from typing import Sequence, Type, Union
 
 from sqlalchemy.orm import Query, Session, aliased
@@ -6,7 +9,8 @@ from sqlalchemy.orm.exc import NoResultFound
 from sqlalchemy.orm.session import Session
 from waveforms.dicttree import foldDict
 
-from .models import Comment, Record, Report, Sample, Tag
+from .models import (Cell, Comment, Config, InputText, Notebook, Record,
+                     Report, Sample, Tag, utcnow)
 
 
 def tag(session: Session, tag_text: str) -> Tag:
@@ -142,3 +146,76 @@ def remove_tags(session: Session, record_id: int, tags: Sequence[str]):
         session.rollback()
         return False
     return True
+
+
+def create_notebook(session: Session, notebook_name: str) -> Notebook:
+    """Create a notebook in the database."""
+    notebook = Notebook(name=notebook_name)
+    session.add(notebook)
+    return notebook
+
+
+def create_input_text(session: Session, input_text: str) -> InputText:
+    """Create an input text in the database."""
+    input = InputText()
+    input.text = input_text
+    try:
+        input = session.query(InputText).filter(
+            InputText.hash == input.hash,
+            InputText.text_field == input_text).one()
+    except NoResultFound:
+        session.add(input)
+    return input
+
+
+def create_cell(session: Session, notebook: Notebook, input_text: str) -> Cell:
+    """Create a cell in the database."""
+    cell = Cell()
+    cell.notebook = notebook
+    cell.input = create_input_text(session, input_text)
+    cell.index = len(notebook.cells) - 1
+    session.add(cell)
+    notebook.atime = cell.ctime
+    return cell
+
+
+def create_config(session: Session, config: dict | bytes, base: Path,
+                  filename: str) -> Config:
+    """Create a config in the database."""
+
+    if not isinstance(config, bytes):
+        buf = pickle.dumps(config)
+        buf = lzma.compress(buf)
+        content_type = 'application/pickle+lzma'
+    else:
+        buf = config
+        content_type = 'application/octet-stream'
+    config = Config(buf)
+    config.content_type = content_type
+    for cfg in session.query(Config).filter(Config.hash == config.hash).all():
+        with open(base / cfg.file, 'rb') as f:
+            if f.read() == buf:
+                cfg.atime = utcnow()
+                return cfg
+    else:
+        path = base / filename
+        path.parent.mkdir(parents=True, exist_ok=True)
+        with open(path, 'wb') as f:
+            f.write(buf)
+        config.file = filename
+        session.add(config)
+    return config
+
+
+def get_config(session: Session, config_id: int, base: Path):
+    config = session.get(Config, config_id)
+    if config is None:
+        return None
+    config.atime = utcnow()
+    path = base / config.file
+    with open(path, 'rb') as f:
+        buf = f.read()
+    if config.content_type == 'application/pickle+lzma':
+        buf = lzma.decompress(buf)
+        buf = pickle.loads(buf)
+    return buf

{qulab-2.1.2 → qulab-2.1.4}/qulab/scan/models.py

@@ -1,11 +1,9 @@
 import hashlib
 import pickle
-import time
 from datetime import datetime, timezone
 from functools import singledispatchmethod
-from typing import Optional
 
-from sqlalchemy import (JSON, Column, DateTime, Float, ForeignKey, Integer,
+from sqlalchemy import (Column, DateTime, Float, ForeignKey, Integer,
                         LargeBinary, String, Table, Text, create_engine)
 from sqlalchemy.orm import (backref, declarative_base, relationship,
                             sessionmaker)
@@ -325,7 +323,7 @@ class InputText(Base):
     __tablename__ = 'inputs'
 
     id = Column(Integer, primary_key=True)
-    hash = Column(LargeBinary(20))
+    hash = Column(LargeBinary(20), index=True)
     text_field = Column(Text, unique=True)
 
     @property
@@ -432,6 +430,22 @@ class SampleTransfer(Base):
     comments = relationship("Comment", secondary=sample_transfer_comments)
 
 
+class Config(Base):
+    __tablename__ = 'configs'
+
+    id = Column(Integer, primary_key=True)
+    hash = Column(LargeBinary(20), index=True)
+    file = Column(String)
+    content_type = Column(String, default='application/pickle')
+    ctime = Column(DateTime, default=utcnow)
+    atime = Column(DateTime, default=utcnow)
+
+    records = relationship("Record", back_populates="config")
+
+    def __init__(self, data: bytes) -> None:
+        self.hash = hashlib.sha1(data).digest()
+
+
 class Record(Base):
     __tablename__ = 'records'
 
@@ -440,14 +454,14 @@ class Record(Base):
     mtime = Column(DateTime, default=utcnow)
     atime = Column(DateTime, default=utcnow)
     user_id = Column(Integer, ForeignKey('users.id'))
+    config_id = Column(Integer, ForeignKey('configs.id'))
     parent_id = Column(Integer, ForeignKey('records.id'))
     cell_id = Column(Integer, ForeignKey('cells.id'))
 
     app = Column(String)
     file = Column(String)
+    content_type = Column(String, default='application/pickle')
     key = Column(String)
-    config = Column(JSON)
-    task_hash = Column(LargeBinary(32))
 
     parent = relationship("Record",
                           remote_side=[id],
@@ -456,6 +470,7 @@ class Record(Base):
                             remote_side=[parent_id],
                             back_populates="parent")
 
+    config = relationship("Config", back_populates="records")
     user = relationship("User")
     samples = relationship("Sample",
                            secondary=sample_records,

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

@@ -12,7 +12,7 @@ from sqlalchemy.orm import sessionmaker
 from qulab.sys.rpc.zmq_socket import ZMQContextManager
 
 from .record import Record
-from .recorder import get_local_record
+from .server import get_local_record
 from .scan import default_server
 
 

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

@@ -95,6 +95,11 @@ class BufferList():
                         dill.dump(item, f)
                 self._list.clear()
 
+    def delete(self):
+        if isinstance(self.file, Path):
+            self.file.unlink()
+            self.file = None
+
     def append(self, pos, value, dims=None):
         if dims is not None:
             if any([p != 0 for i, p in enumerate(pos) if i not in dims]):
@@ -450,6 +455,20 @@ class Record():
         with open(self._file, 'wb') as f:
             dill.dump(self, f)
 
+    def delete(self):
+        if self.is_remote_record():
+            with ZMQContextManager(zmq.DEALER,
+                                   connect=self.database) as socket:
+                socket.send_pyobj({
+                    'method': 'record_delete',
+                    'record_id': self.id
+                })
+        elif self.is_local_record():
+            for key, value in self._items.items():
+                if isinstance(value, BufferList):
+                    value.delete()
+            self._file.unlink()
+
     def export(self, file):
         with zipfile.ZipFile(file,
                              'w',
@@ -470,8 +489,33 @@ class Record():
                 else:
                     items[key] = value
             with z.open('record.pkl', 'w') as f:
+                self.description['entry']['scripts'] = self.scripts()
                 dill.dump((self.description, items), f)
 
+    def scripts(self, session=None):
+        scripts = self.description['entry']['scripts']
+        if isinstance(scripts, list):
+            return scripts
+        else:
+            cell_id = scripts
+
+        if self.is_remote_record():
+            with ZMQContextManager(zmq.DEALER,
+                                   connect=self.database) as socket:
+                socket.send_pyobj({
+                    'method': 'notebook_history',
+                    'cell_id': cell_id
+                })
+                return socket.recv_pyobj()
+        elif self.is_local_record():
+            from .models import Cell
+            assert session is not None, "session is required for local record"
+            cell = session.get(Cell, cell_id)
+            return [
+                cell.input.text
+                for cell in cell.notebook.cells[1:cell.index + 2]
+            ]
+
     @classmethod
     def load(cls, file: str):
         with zipfile.ZipFile(file, 'r') as z:

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

@@ -2,8 +2,12 @@ import asyncio
 import copy
 import inspect
 import itertools
+import lzma
 import os
+import pickle
+import platform
 import re
+import subprocess
 import sys
 import uuid
 from concurrent.futures import ProcessPoolExecutor
@@ -19,7 +23,7 @@ from ..sys.rpc.zmq_socket import ZMQContextManager
 from .expression import Env, Expression, Symbol
 from .optimize import NgOptimizer
 from .record import Record
-from .recorder import default_record_port
+from .server import default_record_port
 from .space import Optimizer, OptimizeSpace, Space
 from .utils import async_zip, call_function, dump_globals
 
@@ -41,6 +45,7 @@ except:
 
 __process_uuid = uuid.uuid1()
 __task_counter = itertools.count()
+__notebook_id = None
 
 if os.getenv('QULAB_SERVER'):
     default_server = os.getenv('QULAB_SERVER')
@@ -52,6 +57,105 @@ else:
     default_executor = default_server
 
 
+def yapf_reformat(cell_text):
+    try:
+        import isort
+        import yapf.yapflib.yapf_api
+
+        fname = f"f{uuid.uuid1().hex}"
+
+        def wrap(source):
+            lines = [f"async def {fname}():"]
+            for line in source.split('\n'):
+                lines.append("    " + line)
+            return '\n'.join(lines)
+
+        def unwrap(source):
+            lines = []
+            for line in source.split('\n'):
+                if line.startswith(f"async def {fname}():"):
+                    continue
+                lines.append(line[4:])
+            return '\n'.join(lines)
+
+        cell_text = re.sub('^%', '#%#', cell_text, flags=re.M)
+        reformated_text = unwrap(
+            yapf.yapflib.yapf_api.FormatCode(wrap(isort.code(cell_text)))[0])
+        return re.sub('^#%#', '%', reformated_text, flags=re.M)
+    except:
+        return cell_text
+
+
+def get_installed_packages():
+    result = subprocess.run([sys.executable, '-m', 'pip', 'freeze'],
+                            stdout=subprocess.PIPE,
+                            text=True)
+
+    lines = result.stdout.split('\n')
+    packages = []
+    for line in lines:
+        if line:
+            packages.append(line)
+    return packages
+
+
+def get_system_info():
+    info = {
+        'OS': platform.uname()._asdict(),
+        'Python': sys.version,
+        'PythonExecutable': sys.executable,
+        'PythonPath': sys.path,
+        'packages': get_installed_packages()
+    }
+    return info
+
+
+def current_notebook():
+    return __notebook_id
+
+
+async def create_notebook(name: str, database=default_server, socket=None):
+    global __notebook_id
+
+    async with ZMQContextManager(zmq.DEALER, connect=database,
+                                 socket=socket) as socket:
+        await socket.send_pyobj({'method': 'notebook_create', 'name': name})
+        __notebook_id = await socket.recv_pyobj()
+
+
+async def save_input_cells(notebook_id,
+                           input_cells,
+                           database=default_server,
+                           socket=None):
+    async with ZMQContextManager(zmq.DEALER, connect=database,
+                                 socket=socket) as socket:
+        await socket.send_pyobj({
+            'method': 'notebook_extend',
+            'notebook_id': notebook_id,
+            'input_cells': input_cells
+        })
+        return await socket.recv_pyobj()
+
+
+async def create_config(config: dict, database=default_server, socket=None):
+    async with ZMQContextManager(zmq.DEALER, connect=database,
+                                 socket=socket) as socket:
+        buf = lzma.compress(pickle.dumps(config))
+        await socket.send_pyobj({'method': 'config_update', 'update': buf})
+        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)))
 
@@ -135,10 +239,11 @@ class Scan():
                  mixin=None):
         self.id = task_uuid()
         self.record = None
-        self.namespace = {}
+        self.config = None
         self.description = {
             'app': app,
             'tags': tags,
+            'config': None,
             'loops': {},
             'intrinsic_loops': {},
             'consts': {},
@@ -157,9 +262,11 @@ class Scan():
             'database': database,
             'hiden': ['self', r'^__.*', r'.*__$'],
             'entry': {
+                'system': get_system_info(),
                 'env': {},
                 'shell': '',
-                'cmds': []
+                'cmds': [],
+                'scripts': []
             },
         }
         self._current_level = 0
@@ -248,8 +355,7 @@ class Scan():
 
     def emit(self, current_level, step, position, variables: dict[str, Any]):
         self._msg_queue.put_nowait(
-            asyncio.create_task(
-                self._emit(current_level, step, position, variables.copy())))
+            self._emit(current_level, step, position, variables.copy()))
 
     def hide(self, name: str):
         self.description['hiden'].append(name)
@@ -287,8 +393,6 @@ class Scan():
     def get(self, name: str):
         if name in self.description['consts']:
             return self.description['consts'][name]
-        elif name in self.namespace:
-            return self.namespace.get(name)
         else:
             return Symbol(name)
 
@@ -442,6 +546,17 @@ 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://"):
@@ -635,13 +750,21 @@ def assymbly(description):
     ipy = get_ipython()
     if ipy is not None:
         description['entry']['shell'] = 'ipython'
-        description['entry']['cmds'] = ipy.user_ns['In']
+        description['entry']['scripts'] = [
+            yapf_reformat(cell_text) for cell_text in ipy.user_ns['In']
+        ]
     else:
         try:
             description['entry']['shell'] = 'shell'
             description['entry']['cmds'] = [
                 sys.executable, __main__.__file__, *sys.argv[1:]
             ]
+            description['entry']['scripts'] = []
+            try:
+                with open(__main__.__file__) as f:
+                    description['entry']['scripts'].append(f.read())
+            except:
+                pass
         except:
             pass
 

qulab-2.1.2/qulab/scan/recorder.py → qulab-2.1.4/qulab/scan/server.py

@@ -11,10 +11,12 @@ from loguru import logger
 
 from qulab.sys.rpc.zmq_socket import ZMQContextManager
 
-from .curd import query_record, remove_tags, tag, update_tags
+from .curd import (create_cell, create_config, create_notebook, get_config,
+                   query_record, remove_tags, tag, update_tags)
+from .models import Cell, Notebook
 from .models import Record as RecordInDB
 from .models import Session, create_engine, create_tables, sessionmaker, utcnow
-from .record import Record
+from .record import BufferList, Record, random_path
 
 try:
     default_record_port = int(os.getenv('QULAB_RECORD_PORT', 6789))
@@ -30,6 +32,8 @@ datapath.mkdir(parents=True, exist_ok=True)
 record_cache = {}
 CACHE_SIZE = 1024
 
+pool = {}
+
 
 class Request():
     __slots__ = ['sock', 'identity', 'msg', 'method']
@@ -62,6 +66,10 @@ def flush_cache():
 def get_local_record(session: Session, id: int, datapath: Path) -> Record:
     record_in_db = session.get(RecordInDB, id)
     record_in_db.atime = utcnow()
+
+    if record_in_db.file.endswith('.zip'):
+        return Record.load(datapath / 'objects' / record_in_db.file)
+
     path = datapath / 'objects' / record_in_db.file
     with open(path, 'rb') as f:
         record = dill.load(f)
@@ -88,6 +96,7 @@ def record_create(session: Session, description: dict, datapath: Path) -> int:
     if 'tags' in description:
         record_in_db.tags = [tag(session, t) for t in description['tags']]
     record_in_db.file = '/'.join(record._file.parts[-4:])
+    record_in_db.config_id = description['config']
     record._file = datapath / 'objects' / record_in_db.file
     session.add(record_in_db)
     try:
@@ -115,6 +124,14 @@ def record_append(session: Session, record_id: int, level: int, step: int,
         raise
 
 
+def record_delete(session: Session, record_id: int, datapath: Path):
+    record = get_local_record(session, record_id, datapath)
+    record.delete()
+    record_in_db = session.get(RecordInDB, record_id)
+    session.delete(record_in_db)
+    session.commit()
+
+
 @logger.catch
 async def handle(session: Session, request: Request, datapath: Path):
 
@@ -162,6 +179,62 @@ async def handle(session: Session, request: Request, datapath: Path):
             update_tags(session, msg['record_id'], msg['tags'], True)
         case 'record_replace_tags':
             update_tags(session, msg['record_id'], msg['tags'], False)
+        case 'notebook_create':
+            notebook = create_notebook(session, msg['name'])
+            session.commit()
+            await reply(request, notebook.id)
+        case 'notebook_extend':
+            notebook = session.get(Notebook, msg['notebook_id'])
+            inputCells = msg.get('input_cells', [""])
+            aready_saved = len(notebook.cells)
+            if len(inputCells) > aready_saved:
+                for cell in inputCells[aready_saved:]:
+                    cell = create_cell(session, notebook, cell)
+                session.commit()
+                await reply(request, cell.id)
+            else:
+                await reply(request, None)
+        case 'notebook_history':
+            cell = session.get(Cell, msg['cell_id'])
+            if cell:
+                await reply(request, [
+                    cell.input.text
+                    for cell in cell.notebook.cells[1:cell.index + 2]
+                ])
+            else:
+                await reply(request, None)
+        case 'config_get':
+            config = get_config(session,
+                                msg['config_id'],
+                                base=datapath / 'objects')
+            session.commit()
+            await reply(request, config)
+        case 'config_update':
+            config = create_config(session,
+                                   msg['update'],
+                                   base=datapath / 'objects',
+                                   filename='/'.join(
+                                       random_path(datapath /
+                                                   'objects').parts[-4:]))
+            session.commit()
+            await reply(request, config.id)
+        case 'submit':
+            from .scan import Scan
+            description = dill.loads(msg['description'])
+            task = Scan()
+            task.description = description
+            task.start()
+            pool[task.id] = task
+            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)
+            else:
+                await reply(request, None)
         case _:
             logger.error(f"Unknown method: {msg['method']}")
 
@@ -239,9 +312,9 @@ async def main(port, datapath, url, timeout=1, buffer=1024, interval=60):
 @click.option('--interval',
               default=60,
               help='Interval of flush cache, in unit of second.')
-def record(port, datapath, url, timeout, buffer, interval):
+def server(port, datapath, url, timeout, buffer, interval):
     asyncio.run(main(port, Path(datapath), url, timeout, buffer, interval))
 
 
 if __name__ == "__main__":
-    record()
+    server()

{qulab-2.1.2 → qulab-2.1.4}/qulab/sys/rpc/zmq_socket.py

@@ -98,7 +98,8 @@ class ZMQContextManager:
                  public_keys_location: Optional[str] = None,
                  secret_key: Optional[bytes] = None,
                  public_key: Optional[bytes] = None,
-                 server_public_key: Optional[bytes] = None):
+                 server_public_key: Optional[bytes] = None,
+                 socket: Optional[zmq.Socket] = None):
         self.socket_type = socket_type
         if bind is None and connect is None:
             raise ValueError("Either 'bind' or 'connect' must be specified.")
@@ -129,6 +130,7 @@ class ZMQContextManager:
         self.auth = None
         self.context = None
         self.socket = None
+        self._external_socket = socket
 
     def _create_socket(self, asyncio=False) -> zmq.Socket:
         """
@@ -138,6 +140,8 @@ class ZMQContextManager:
         Returns:
             zmq.Socket: The configured ZeroMQ socket.
         """
+        if self._external_socket:
+            return self._external_socket
         if asyncio:
             self.context = zmq.asyncio.Context()
         else:
@@ -185,6 +189,8 @@ class ZMQContextManager:
         Closes the ZeroMQ socket and the context, and stops the authenticator
         if it was started.
         """
+        if self._external_socket:
+            return
         if self.observer:
             self.observer.stop()
             self.observer.join()

qulab-2.1.4/qulab/version.py

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

qulab-2.1.2/qulab/scan/server.py

@@ -1,104 +0,0 @@
-import asyncio
-import pickle
-
-import click
-import dill
-import zmq
-from loguru import logger
-
-from qulab.sys.rpc.zmq_socket import ZMQContextManager
-
-from .scan import Scan
-
-pool = {}
-
-
-class Request():
-    __slots__ = ['sock', 'identity', 'msg', 'method']
-
-    def __init__(self, sock, identity, msg):
-        self.sock = sock
-        self.identity = identity
-        self.msg = pickle.loads(msg)
-        self.method = self.msg.get('method', '')
-
-
-async def reply(req, resp):
-    await req.sock.send_multipart([req.identity, pickle.dumps(resp)])
-
-
-@logger.catch
-async def handle(request: Request):
-
-    msg = request.msg
-
-    match request.method:
-        case 'ping':
-            await reply(request, 'pong')
-        case 'submit':
-            description = dill.loads(msg['description'])
-            task = Scan()
-            task.description = description
-            task.start()
-            pool[task.id] = task
-            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)
-            else:
-                await reply(request, None)
-        case _:
-            logger.error(f"Unknown method: {msg['method']}")
-
-
-async def _handle(request: Request):
-    try:
-        await handle(request)
-    except:
-        await reply(request, 'error')
-
-
-async def serv(port):
-    logger.info('Server starting.')
-    async with ZMQContextManager(zmq.ROUTER, bind=f"tcp://*:{port}") as sock:
-        logger.info('Server started.')
-        while True:
-            identity, msg = await sock.recv_multipart()
-            req = Request(sock, identity, msg)
-            asyncio.create_task(_handle(req))
-
-
-async def watch(port, timeout=1):
-    with ZMQContextManager(zmq.DEALER,
-                           connect=f"tcp://127.0.0.1:{port}") as sock:
-        sock.setsockopt(zmq.LINGER, 0)
-        while True:
-            try:
-                sock.send_pyobj({"method": "ping"})
-                if sock.poll(int(1000 * timeout)):
-                    sock.recv()
-                else:
-                    raise asyncio.TimeoutError()
-            except (zmq.error.ZMQError, asyncio.TimeoutError):
-                return asyncio.create_task(serv(port))
-            await asyncio.sleep(timeout)
-
-
-async def main(port, timeout=1):
-    task = await watch(port=port, timeout=timeout)
-    await task
-
-
-@click.command()
-@click.option('--port', default=6788, help='Port of the server.')
-@click.option('--timeout', default=1, help='Timeout of ping.')
-def server(port, timeout):
-    asyncio.run(main(port, timeout))
-
-
-if __name__ == "__main__":
-    server()

qulab-2.1.2/qulab/version.py

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