Merge pull request #595 from qiboteam/bot

Add platform and backend entries to qq commands

runcards/monitor.yml

@@ -0,0 +1,38 @@
+
+actions:
+
+ - id: t1
+ priority: 00
+ operation: t1_msr
+ main: t2
+ parameters:
+ delay_before_readout_start: 50
+ delay_before_readout_end: 100000
+ delay_before_readout_step: 2500
+ nshots: 1024
+
+ - id: t2
+ priority: 10
+ operation: t2_msr
+ main: readout characterization
+ parameters:
+ delay_between_pulses_start: 50
+ delay_between_pulses_end: 100000
+ delay_between_pulses_step: 2500
+ nshots: 1024
+
+ - id: readout characterization
+ priority: 20
+ # main: standard rb bootstrap
+ operation: readout_characterization
+ parameters:
+ nshots: 5000
+
+ # - id: standard rb bootstrap
+ # priority: 40
+ # operation: standard_rb
+ # parameters:
+ # depths: [10, 100, 150, 200, 250, 300]
+ # niter: 8
+ # nshots: 256
+ # n_bootstrap: 10

src/qibocal/auto/runcard.py

@@ -1,4 +1,5 @@
 """Specify runcard layout, handles (de)serialization."""
+import os
 from functools import cached_property
 from typing import Any, NewType, Optional, Union
 
@@ -47,10 +48,9 @@ class Runcard:
  """Structure of an execution runcard."""
 
  actions: list[Action]
- qubits: Union[list[QubitId], list[tuple[QubitId, QubitId]]]
+ qubits: Optional[Union[list[QubitId], list[tuple[QubitId, QubitId]]]] = None
  backend: str = "qibolab"
- platform: str = "dummy"
- # TODO: pass custom runcard (?)
+ platform: str = os.environ.get("QIBO_PLATFORM", "dummy")
 
  @cached_property
  def backend_obj(self) -> Backend:

src/qibocal/cli/_base.py

@@ -5,6 +5,7 @@
 import click
 import yaml
 
+from ..auto.runcard import Runcard
 from .acquisition import acquire as acquisition
 from .autocalibration import autocalibrate
 from .fit import fit as fitting
@@ -43,23 +44,39 @@ def command():
  help="Use --no-update option to avoid updating iteratively the platform."
  "With this option the new runcard will not be produced.",
 )
-def auto(runcard, folder, force, update):
+@click.option(
+ "--platform",
+ default=None,
+ help="Name of the Qibolab platform.",
+)
+@click.option(
+ "--backend",
+ default=None,
+ help="Name of the Qibo backend.,",
+)
+def auto(runcard, folder, force, update, platform, backend):
  """Autocalibration
 
  Arguments:
 
  - RUNCARD: runcard with declarative inputs.
  """
- card = yaml.safe_load(runcard.read_text(encoding="utf-8"))
- autocalibrate(card, folder, force, update)
+ runcard = Runcard.load(yaml.safe_load(runcard.read_text(encoding="utf-8")))
+
+ if platform is not None:
+ runcard.platform = platform
+ if backend is not None:
+ runcard.backend = backend
+
+ autocalibrate(runcard, folder, force, update)
 
 
 @command.command(context_settings=CONTEXT_SETTINGS)
 @click.argument(
  "runcard", metavar="RUNCARD", type=click.Path(exists=True, path_type=pathlib.Path)
 )
 @click.option(
- "folder",
+ "--folder",
  "-o",
  type=click.Path(path_type=pathlib.Path),
  help="Output folder. If not provided a standard name will generated.",
@@ -70,15 +87,31 @@ def auto(runcard, folder, force, update):
  is_flag=True,
  help="Use --force option to overwrite the output folder.",
 )
-def acquire(runcard, folder, force):
+@click.option(
+ "--platform",
+ default=None,
+ help="Name of the Qibolab platform.",
+)
+@click.option(
+ "--backend",
+ default=None,
+ help="Name of the Qibo backend.,",
+)
+def acquire(runcard, folder, force, platform, backend):
  """Data acquisition
 
  Arguments:
 
  - RUNCARD: runcard with declarative inputs.
  """
- card = yaml.safe_load(runcard.read_text(encoding="utf-8"))
- acquisition(card, folder, force)
+ runcard = Runcard.load(yaml.safe_load(runcard.read_text(encoding="utf-8")))
+
+ if platform is not None:
+ runcard.platform = platform
+ if backend is not None:
+ runcard.backend = backend
+
+ acquisition(runcard, folder, force)
 
 
 @command.command(context_settings=CONTEXT_SETTINGS)

src/qibocal/cli/acquisition.py

@@ -8,7 +8,6 @@
 from ..auto.execute import Executor
 from ..auto.history import add_timings_to_meta
 from ..auto.mode import ExecutionMode
-from ..auto.runcard import Runcard
 from .utils import (
  META,
  PLATFORM,
@@ -19,33 +18,34 @@
 )
 
 
-def acquire(card, folder, force):
+def acquire(runcard, folder, force):
  """Data acquisition
 
  Arguments:
 
  - RUNCARD: runcard with declarative inputs.
  """
- # load and initialize Runcard from file
- runcard = Runcard.load(card)
 
+ # rename for brevity
+ backend = runcard.backend_obj
+ platform = runcard.platform_obj
  # generate output folder
  path = generate_output_folder(folder, force)
- # generate meta
- meta = generate_meta(runcard, path)
 
+ # set backend, platform and qubits
+ qubits = create_qubits_dict(qubits=runcard.qubits, platform=platform)
+
+ # generate meta
+ meta = generate_meta(backend, platform, path)
  # dump platform
- if runcard.backend == "qibolab":
- dump_runcard(runcard.platform_obj, path / PLATFORM)
+ if backend.name == "qibolab":
+ dump_runcard(platform, path / PLATFORM)
 
  # dump action runcard
  (path / RUNCARD).write_text(yaml.safe_dump(asdict(runcard)))
  # dump meta
  (path / META).write_text(json.dumps(meta, indent=4))
 
- # allocate qubits, runcard and executor
- qubits = create_qubits_dict(runcard)
- platform = runcard.platform_obj
  executor = Executor.load(runcard, path, platform, qubits)
 
  # connect and initialize platform
@@ -59,6 +59,7 @@ def acquire(card, folder, force):
 
  e = datetime.datetime.now(datetime.timezone.utc)
  meta["end-time"] = e.strftime("%H:%M:%S")
+
  # stop and disconnect platform
  if platform is not None:
  platform.stop()

src/qibocal/cli/autocalibration.py

@@ -8,7 +8,6 @@
 from ..auto.execute import Executor
 from ..auto.history import add_timings_to_meta
 from ..auto.mode import ExecutionMode
-from ..auto.runcard import Runcard
 from ..cli.report import ReportBuilder
 from .utils import (
  META,
@@ -21,32 +20,35 @@
 )
 
 
-def autocalibrate(card, folder, force, update):
+def autocalibrate(runcard, folder, force, update):
  """Autocalibration
 
  Arguments:
 
  - RUNCARD: runcard with declarative inputs.
  """
- # load and initialize Runcard from file
- runcard = Runcard.load(card)
 
+ # rename for brevity
+ backend = runcard.backend_obj
+ platform = runcard.platform_obj
  # generate output folder
  path = generate_output_folder(folder, force)
- # generate meta
- meta = generate_meta(runcard, path)
 
+ # allocate qubits
+ qubits = create_qubits_dict(qubits=runcard.qubits, platform=platform)
+
+ # generate meta
+ meta = generate_meta(backend, platform, path)
  # dump platform
- if runcard.backend == "qibolab":
- dump_runcard(runcard.platform_obj, path / PLATFORM)
+ if backend.name == "qibolab":
+ dump_runcard(platform, path / PLATFORM)
+
  # dump action runcard
  (path / RUNCARD).write_text(yaml.safe_dump(asdict(runcard)))
  # dump meta
  (path / META).write_text(json.dumps(meta, indent=4))
 
- # allocate qubits, runcard and executor
- qubits = create_qubits_dict(runcard)
- platform = runcard.platform_obj
+ # allocate executor
  executor = Executor.load(runcard, path, platform, qubits, update)
 
  # connect and initialize platform
@@ -55,13 +57,14 @@ def autocalibrate(card, folder, force, update):
  platform.setup()
  platform.start()
 
- e = datetime.datetime.now(datetime.timezone.utc)
- meta["end-time"] = e.strftime("%H:%M:%S")
  # run protocols
- for task_uid in executor.run(mode=ExecutionMode.autocalibration):
- report = ReportBuilder(path, runcard.qubits, executor, meta, executor.history)
+ for _ in executor.run(mode=ExecutionMode.autocalibration):
+ report = ReportBuilder(path, qubits, executor, meta, executor.history)
  report.run(path)
 
+ e = datetime.datetime.now(datetime.timezone.utc)
+ meta["end-time"] = e.strftime("%H:%M:%S")
+
  # stop and disconnect platform
  if platform is not None:
  platform.stop()

src/qibocal/cli/fit.py

@@ -2,6 +2,7 @@
 import json
 
 import yaml
+from qibo.backends import GlobalBackend
 from qibolab.serialize import dump_runcard
 
 from ..auto.execute import Executor
@@ -19,23 +20,34 @@ def fit(path, update):
  - FOLDER: input folder.
 
  """
- # load path, meta, runcard and executor
- meta = yaml.safe_load((path / META).read_text())
+ # load meta
+ meta = json.loads((path / META).read_text())
+ # load runcard
  runcard = Runcard.load(yaml.safe_load((path / RUNCARD).read_text()))
- qubits = create_qubits_dict(runcard)
+
+ # set backend, platform and qubits
+ GlobalBackend.set_backend(backend=meta["backend"], platform=meta["platform"])
+ backend = GlobalBackend()
+ platform = backend.platform
+ qubits = create_qubits_dict(qubits=runcard.qubits, platform=platform)
+
+ # load executor
  executor = Executor.load(
- runcard, path, update=update, platform=runcard.platform_obj, qubits=qubits
+ runcard, path, update=update, platform=platform, qubits=qubits
  )
 
  # perform post-processing
  list(executor.run(mode=ExecutionMode.fit))
 
- # dump updated runcard
- if runcard.platform_obj is not None and update:
- dump_runcard(runcard.platform_obj, path / UPDATED_PLATFORM)
-
- # update time in meta.yml
+ # update time in meta
  meta = add_timings_to_meta(meta, executor.history)
  e = datetime.datetime.now(datetime.timezone.utc)
  meta["end-time"] = e.strftime("%H:%M:%S")
+
+ # dump updated runcard
+ if platform is not None and update: # pragma: no cover
+ # cannot test update since dummy may produce wrong values and trigger errors
+ dump_runcard(platform, path / UPDATED_PLATFORM)
+
+ # dump json
  (path / META).write_text(json.dumps(meta, indent=4))

src/qibocal/cli/report.py

@@ -1,8 +1,10 @@
+import json
 import tempfile
 from functools import cached_property
 from pathlib import Path
 
 import yaml
+from qibo.backends import GlobalBackend
 from qibolab.qubits import QubitId
 
 from qibocal.auto.execute import Executor
@@ -26,15 +28,22 @@ def report(path):
  - FOLDER: input folder.
 
  """
- # load path, meta and runcard
- meta = yaml.safe_load((path / META).read_text())
+ # load meta
+ meta = json.loads((path / META).read_text())
+ # load runcard
  runcard = Runcard.load(yaml.safe_load((path / RUNCARD).read_text()))
- qubits = create_qubits_dict(runcard)
+
+ # set backend, platform and qubits
+ GlobalBackend.set_backend(backend=meta["backend"], platform=meta["platform"])
+ backend = GlobalBackend()
+ platform = backend.platform
+ qubits = create_qubits_dict(qubits=runcard.qubits, platform=platform)
+
  # load executor
  executor = Executor.load(runcard, path, qubits=qubits)
 
  # produce html
- builder = ReportBuilder(path, runcard.qubits, executor, meta)
+ builder = ReportBuilder(path, qubits, executor, meta)
  builder.run(path)