From 97ee27aabb15fa6c0e3b2425cac1fd59206851af Mon Sep 17 00:00:00 2001 From: JMit-dev Date: Wed, 30 Jul 2025 12:33:09 -0400 Subject: [PATCH 1/2] feat: add bluesky queue server and http service docker compose files --- .../bluesky-services/Dockerfile.http-server | 25 + .../bluesky-services/Dockerfile.queue-server | 28 + services/bluesky-services/README.md | 100 + services/bluesky-services/docker-compose.yml | 72 + .../profile_collection_sim/history.sqlite | Bin 0 -> 28672 bytes .../profile_collection_sim/ipython_config.py | 7 + .../startup/00-ophyd.py | 10 + .../startup/05-run-engine.py | 25 + .../startup/15-plans.py | 40 + .../startup/99-custom.py | 281 ++ .../startup/existing_plans_and_devices.yaml | 3609 +++++++++++++++++ .../startup/user_group_permissions.yaml | 48 + 12 files changed, 4245 insertions(+) create mode 100644 services/bluesky-services/Dockerfile.http-server create mode 100644 services/bluesky-services/Dockerfile.queue-server create mode 100644 services/bluesky-services/README.md create mode 100644 services/bluesky-services/docker-compose.yml create mode 100644 services/bluesky-services/ipython-profile/profile_collection_sim/history.sqlite create mode 100644 services/bluesky-services/ipython-profile/profile_collection_sim/ipython_config.py create mode 100644 services/bluesky-services/ipython-profile/profile_collection_sim/startup/00-ophyd.py create mode 100644 services/bluesky-services/ipython-profile/profile_collection_sim/startup/05-run-engine.py create mode 100644 services/bluesky-services/ipython-profile/profile_collection_sim/startup/15-plans.py create mode 100644 services/bluesky-services/ipython-profile/profile_collection_sim/startup/99-custom.py create mode 100644 services/bluesky-services/ipython-profile/profile_collection_sim/startup/existing_plans_and_devices.yaml create mode 100644 services/bluesky-services/ipython-profile/profile_collection_sim/startup/user_group_permissions.yaml diff --git a/services/bluesky-services/Dockerfile.http-server b/services/bluesky-services/Dockerfile.http-server new file mode 100644 index 0000000000..00ea760ee5 --- /dev/null +++ b/services/bluesky-services/Dockerfile.http-server @@ -0,0 +1,25 @@ +# Bluesky HTTP Server +FROM python:3.11-slim + +# Install system dependencies +RUN apt-get update && apt-get install -y \ + git \ + && rm -rf /var/lib/apt/lists/* + +# Install bluesky-httpserver and dependencies +RUN pip install --no-cache-dir \ + bluesky-httpserver \ + uvicorn \ + fastapi \ + pandas + +# Create working directory +WORKDIR /app + +# Expose HTTP port +EXPOSE 60610 + +# Set environment variables +ENV QSERVER_HTTP_SERVER_SINGLE_USER_API_KEY=a + +CMD ["uvicorn", "--host", "0.0.0.0", "--port", "60610", "bluesky_httpserver.server:app"] \ No newline at end of file diff --git a/services/bluesky-services/Dockerfile.queue-server b/services/bluesky-services/Dockerfile.queue-server new file mode 100644 index 0000000000..6cdbb12172 --- /dev/null +++ b/services/bluesky-services/Dockerfile.queue-server @@ -0,0 +1,28 @@ +# Bluesky Queue Server (RE Manager) +FROM python:3.11-slim + +# Install system dependencies +RUN apt-get update && apt-get install -y \ + git \ + build-essential \ + && rm -rf /var/lib/apt/lists/* + +# Install bluesky-queueserver and dependencies +RUN pip install --no-cache-dir \ + bluesky-queueserver \ + bluesky \ + ophyd \ + ipython \ + matplotlib \ + numpy + +# Create working directory +WORKDIR /app + +# Copy IPython profile from local directory +COPY ipython-profile/ /root/.ipython/ + +# Expose port for 0MQ communication +EXPOSE 60615 + +CMD ["sh", "-c", "start-re-manager --use-ipython-kernel=ON --zmq-publish-console=ON --startup-profile collection_sim --redis-addr=${REDIS_HOST:-redis}:${REDIS_PORT:-6379}"] \ No newline at end of file diff --git a/services/bluesky-services/README.md b/services/bluesky-services/README.md new file mode 100644 index 0000000000..e3ecf3d2cf --- /dev/null +++ b/services/bluesky-services/README.md @@ -0,0 +1,100 @@ +gg# Bluesky Services Docker Setup + +This directory contains Docker configurations for running Bluesky Queue Server and HTTP Server for the Phoebus queue-server application. + +## Services + +- **queue-server**: Bluesky Queue Server (RE Manager) - manages the execution queue +- **http-server**: Bluesky HTTP Server - provides REST API interface for the Java client +- **redis**: Redis database for queue persistence + +## Quick Start + +### Option 1: Use Host Redis (if you have Redis running) +```bash +cd services/bluesky-services +docker-compose up -d queue-server http-server +``` + +### Option 2: Use Container Redis (recommended) +```bash +cd services/bluesky-services +docker-compose --profile container-redis up -d +``` + +### Common Commands +1. **Check service status:** + ```bash + docker-compose ps + ``` + +2. **View logs:** + ```bash + docker-compose logs -f + # Or for specific service: + docker-compose logs -f queue-server + ``` + +3. **Stop services:** + ```bash + docker-compose down + ``` + +4. **Rebuild after changes:** + ```bash + docker-compose build + ``` + +## Accessing Services + +- **HTTP Server API**: http://localhost:60610 +- **Queue Server ZMQ**: tcp://localhost:60615 +- **Redis**: localhost:6380 (when using container Redis) + +## API Authentication + +The HTTP server uses API key `a` by default. Test the connection: + +```bash +# Test status endpoint +curl "http://localhost:60610/api/status?api_key=a" + +# Test plans endpoint +curl "http://localhost:60610/api/plans/allowed?api_key=a" +``` + +## Configuration Files + +- **ipython-profile/**: Contains the IPython profile with startup scripts +- **ipython-profile/profile_collection_sim/startup/**: Startup scripts loaded by the queue server + - `00-ophyd.py`: Device definitions + - `05-run-engine.py`: Run engine setup + - `15-plans.py`: Plan definitions + - `99-custom.py`: Custom configurations + - `existing_plans_and_devices.yaml`: Plans and devices configuration + - `user_group_permissions.yaml`: User permissions + +## Using with Phoebus + +1. Start the containers using the commands above +2. In Phoebus, set the queue server URL to: `http://localhost:60610` +3. Set the API key to: `a` +4. The Java client will connect to the HTTP server, which communicates with the queue server + +## Troubleshooting + +**Connection timeouts:** +- Ensure both containers are healthy: `docker-compose ps` +- Check queue server logs: `docker-compose logs queue-server` +- Check HTTP server logs: `docker-compose logs http-server` + +**Port conflicts:** +- If port 6379 is in use, the container Redis uses port 6380 externally +- If ports 60610 or 60615 are in use, stop any existing bluesky processes + +**Rebuild everything:** +```bash +docker-compose down +docker-compose build --no-cache +docker-compose --profile container-redis up -d +``` \ No newline at end of file diff --git a/services/bluesky-services/docker-compose.yml b/services/bluesky-services/docker-compose.yml new file mode 100644 index 0000000000..6a9bd48b93 --- /dev/null +++ b/services/bluesky-services/docker-compose.yml @@ -0,0 +1,72 @@ +services: + # Optional Redis container - only used if host Redis is not available + redis: + image: redis:7-alpine + container_name: bluesky-redis + ports: + - "6380:6379" # Use different external port to avoid conflicts + command: redis-server --appendonly yes + volumes: + - redis_data:/data + networks: + - bluesky-network + healthcheck: + test: ["CMD", "redis-cli", "ping"] + interval: 10s + timeout: 5s + retries: 5 + profiles: + - container-redis # Only start when explicitly requested + + queue-server: + build: + context: . + dockerfile: Dockerfile.queue-server + container_name: bluesky-queue-server + ports: + - "60615:60615" + environment: + - REDIS_HOST=redis + - REDIS_PORT=6379 + extra_hosts: + - "host.docker.internal:host-gateway" # Allow access to host services + networks: + - bluesky-network + restart: unless-stopped + healthcheck: + test: ["CMD", "python", "-c", "import zmq; c = zmq.Context(); s = c.socket(zmq.REQ); s.connect('tcp://localhost:60615'); s.close(); c.term()"] + interval: 30s + timeout: 10s + retries: 3 + start_period: 30s + + http-server: + build: + context: . + dockerfile: Dockerfile.http-server + container_name: bluesky-http-server + ports: + - "60610:60610" + environment: + - QSERVER_HTTP_SERVER_SINGLE_USER_API_KEY=a + - QSERVER_ZMQ_CONTROL_ADDRESS=tcp://queue-server:60615 + depends_on: + queue-server: + condition: service_healthy + networks: + - bluesky-network + restart: unless-stopped + healthcheck: + test: ["CMD", "curl", "-f", "http://localhost:60610/api/status"] + interval: 30s + timeout: 10s + retries: 3 + start_period: 30s + +networks: + bluesky-network: + driver: bridge + +volumes: + redis_data: + driver: local \ No newline at end of file diff --git a/services/bluesky-services/ipython-profile/profile_collection_sim/history.sqlite b/services/bluesky-services/ipython-profile/profile_collection_sim/history.sqlite new file mode 100644 index 0000000000000000000000000000000000000000..a8b3603f8b05aeecd603f308a2090079558c9252 GIT binary patch literal 28672 zcmeI3O>7)V6~|}dWM({`8E5(Ove_(;?|5Su_1#sSWwEn(H;8NqAslkSc#{UKjmO!U zF>EA|NQ5|WLI@#lNC+V=To6Kt11E$K2To{(5XTilD^45`LJ0Bi_L$9d_xOUu!FsK+ zJnjCurrxjKd)2KtpZet0-AP8D+aK-iOvp6OHk!@G22rEYxQ4GbzK)Isyg7Yzg73{o z-p_k`ts%bgSby-lMyvOFWBJ11wf-A}@AY2q|9IXn@Xy%*8(;%$fDNz#Hoykh02^Qf z|BHbK&!1_ptgbd6zA)K&>29`vFu8Xy+5W=rc(OmbKYP}C?#9;U%`LjQdHL!V&0g!$ zF~@~*HXiTp4{3Ke$v&Tr*68l;Fnjata44E&uTIvE9q9UvkG;5g;}(5<>lPgidN|nX z>ZMj|9^A} zaZi6(JI|vzy&2kUpyU06(e3OoP&z!>9_@VTn8=Tdc>Q#1W%Jy;h^O=1R?|0UkR_cw zQ?8$Ctz5j=yj4Ux6*bOYImm{$v(o9pOys4D7lu1~*&2Rx^}(l`?UnQAn-9NoIOgGM zkEg3XJ~cba^y+^X@JLpz(W9)oH`?9X8QrIsv-@|8n`u%jxptgTD`cKlsVu zn}gxt>fq@?r~l{vulnEbf3^Ra{xkh2djIIX*86GiTfKX|YrVBzcj+%nzh3&m(!-_C zEu9T%Nb)ff8N5{V z(JG-+Yg40yi8^{i&y@&6%B04o(hF^q=rvs~5t=YfYf>wPHi>kaHfITmXnm^jDM2W! zjrX)sC0yz}UP8yVWRLT%c$sLi9mFD`XC(ShekN`bS;7W zKxJcLjHT5ofy#!~h**3ufi6@COcT{m#Ns5f@Pl=PMmPp5r)@CwfjR%y&yZBqjy&cv}K#nD7WqCEY#L?qb0)>x8r9?=i zL@X;60!ftdbWxS-wx4EF` zttA4r@31JTN`#dr37+0kC9qc(dsL#d)|MVC5!iv?qsVpd6?zPvtrAGVB#$;oY;=K^ zD?~m({y_q|A~I-DB2@kt&yj_IYjO>Dr|JLR3&U`L%y~S zv7+|7Rl=a{=X<5I$Ph`3RYD>K(J)cBGGE(HErEK8s28KqrP{Rwnm_j2;8c**sw3bO zb?XzuDA<(WCV%3A0@E`PDg0gj(}MzAx(s@(g?VM zeaTy!Oy`h4|2LQa*1(GoHoykh02^QfY=8~00XDz}*Z><~18m^L80a+@&Nq+#ZsAJ) z{Et8S=YtKf0XDz}*Z><~18jf|umLu}2G{@_IKc+Gd2Iare}Y$-Lt_JMfDNz#Hoykh z02^QfY=8~00XBgD=$T94=YLKGHoykh02^QfY=8~00XDz}*Z><~11H)5|NH-mUS1B4 b4X^<=zy{a=8(;%$fDNz#HoykhKw;oN%Lw0J literal 0 HcmV?d00001 diff --git a/services/bluesky-services/ipython-profile/profile_collection_sim/ipython_config.py b/services/bluesky-services/ipython-profile/profile_collection_sim/ipython_config.py new file mode 100644 index 0000000000..8fb6497ebd --- /dev/null +++ b/services/bluesky-services/ipython-profile/profile_collection_sim/ipython_config.py @@ -0,0 +1,7 @@ +# IPython configuration for collection_sim profile +c = get_config() + +# Basic configuration +c.InteractiveShellApp.exec_lines = [] +c.InteractiveShellApp.extensions = [] +c.TerminalIPythonApp.display_banner = False \ No newline at end of file diff --git a/services/bluesky-services/ipython-profile/profile_collection_sim/startup/00-ophyd.py b/services/bluesky-services/ipython-profile/profile_collection_sim/startup/00-ophyd.py new file mode 100644 index 0000000000..e2dc3131a0 --- /dev/null +++ b/services/bluesky-services/ipython-profile/profile_collection_sim/startup/00-ophyd.py @@ -0,0 +1,10 @@ +# flake8: noqa +print(f"Loading file {__file__!r}") + +# Import some built-in plans +from bluesky.plan_stubs import mv, mvr, null +from ophyd.sim import hw + +# Import ALL simulated Ophyd objects in global namespace (borrowed from ophyd.sim) +globals().update(hw().__dict__) +del hw diff --git a/services/bluesky-services/ipython-profile/profile_collection_sim/startup/05-run-engine.py b/services/bluesky-services/ipython-profile/profile_collection_sim/startup/05-run-engine.py new file mode 100644 index 0000000000..5f14e32493 --- /dev/null +++ b/services/bluesky-services/ipython-profile/profile_collection_sim/startup/05-run-engine.py @@ -0,0 +1,25 @@ +# flake8: noqa +print(f"Loading file {__file__!r}") + +from bluesky import RunEngine +from bluesky.callbacks.best_effort import BestEffortCallback + +from bluesky_queueserver import is_ipython_mode + +# Detect if the code is executed in IPython environment and backend uses Qt +ipython_matplotlib = False +try: + import matplotlib + + if matplotlib.get_backend().startswith("qt"): + ipython_matplotlib = True +except Exception: + pass + +RE = RunEngine() + +bec = BestEffortCallback() +if not is_ipython_mode() or not ipython_matplotlib: + bec.disable_plots() + +RE.subscribe(bec) diff --git a/services/bluesky-services/ipython-profile/profile_collection_sim/startup/15-plans.py b/services/bluesky-services/ipython-profile/profile_collection_sim/startup/15-plans.py new file mode 100644 index 0000000000..25c942c2ca --- /dev/null +++ b/services/bluesky-services/ipython-profile/profile_collection_sim/startup/15-plans.py @@ -0,0 +1,40 @@ +# flake8: noqa +print(f"Loading file {__file__!r}") + +from typing import Any, Dict, List, Optional + +from bluesky.plans import ( + adaptive_scan, + count, + fly, + grid_scan, + inner_product_scan, + list_grid_scan, + list_scan, + log_scan, + ramp_plan, + rel_adaptive_scan, + rel_grid_scan, + rel_list_grid_scan, + rel_list_scan, + rel_log_scan, + rel_scan, + rel_spiral, + rel_spiral_fermat, + rel_spiral_square, + relative_inner_product_scan, + scan, + scan_nd, + spiral, + spiral_fermat, + spiral_square, + tune_centroid, + tweak, + x2x_scan, +) + + +def marked_up_count( + detectors: List[Any], num: int = 1, delay: Optional[float] = None, md: Optional[Dict[str, Any]] = None +): + return (yield from count(detectors, num=num, delay=delay, md=md)) diff --git a/services/bluesky-services/ipython-profile/profile_collection_sim/startup/99-custom.py b/services/bluesky-services/ipython-profile/profile_collection_sim/startup/99-custom.py new file mode 100644 index 0000000000..3f17bc5373 --- /dev/null +++ b/services/bluesky-services/ipython-profile/profile_collection_sim/startup/99-custom.py @@ -0,0 +1,281 @@ +# flake8: noqa +print(f"Loading file {__file__!r}") + +import time as ttime +import typing + +import bluesky +import bluesky.plan_stubs as bps +import bluesky.preprocessors as bpp +import ophyd +from ophyd import Component as Cpt # Keep 'Device' imported, used in unit tests +from ophyd import Device + +from bluesky_queueserver.manager.annotation_decorator import parameter_annotation_decorator + +# Some useless devices for unit tests. +custom_test_device = ophyd.Device(name="custom_test_device") +custom_test_signal = ophyd.Signal(name="custom_test_signal") +custom_test_flyer = ophyd.sim.MockFlyer("custom_test_flyer", ophyd.sim.det, ophyd.sim.motor, 1, 5, 20) + + +@parameter_annotation_decorator( + { + "description": "Move motors into positions; then count dets.", + "parameters": { + "motors": { + "description": "List of motors to be moved into specified positions before the measurement", + "annotation": "typing.List[Motors]", + "devices": {"Motors": ("motor1", "motor2")}, + }, + "detectors": { + "description": "Detectors to use for measurement.", + "annotation": "typing.List[Detectors]", + "devices": {"Detectors": ("det1", "det2", "det3")}, + "default": ["det1", "det2"], + }, + "positions": { + "description": "Motor positions. The number of positions must be equal " + "to the number of the motors.", + "annotation": "typing.List[float]", + "min": -10, + "max": 10, + "step": 0.01, + }, + }, + } +) +def move_then_count( + motors: typing.List[ophyd.device.Device], + detectors: typing.Optional[typing.List[ophyd.device.Device]] = None, + positions: typing.Optional[typing.List[float]] = None, +) -> typing.Generator[bluesky.utils.Msg, None, None]: + if not isinstance(motors, (list, tuple)): + raise TypeError(f"Parameter 'motors' should be a list or a tuple: type(motors) = {type(motors)}") + if not isinstance(detectors, (list, tuple)): + raise TypeError(f"Parameter 'detectors' should be a list or a tuple: type(detectors) = {type(detectors)}") + if not isinstance(positions, (list, tuple)): + raise TypeError(f"Parameter 'positions' should be a list or a tuple: type(positions) = {type(positions)}") + if len(motors) != len(positions): + raise TypeError( + f"The lists of 'motors' and 'positions' should have the same number of elements: " + f"len(motors) = {len(motors)}, len(positions) = {len(positions)}" + ) + + mv_args = [val for tup in zip(motors, positions) for val in tup] + yield from bps.mv(*mv_args) + yield from count(detectors) + + +@bpp.set_run_key_decorator("run_2") +@bpp.run_decorator(md={}) +def _sim_plan_inner(npts: int, delay: float = 1.0): + for j in range(npts): + yield from bps.mov(motor1, j * 0.1 + 1, motor2, j * 0.2 - 2) + yield from bps.trigger_and_read([motor1, motor2, det2]) + yield from bps.sleep(delay) + + +@bpp.set_run_key_decorator("run_1") +@bpp.run_decorator(md={}) +@parameter_annotation_decorator( + { + "description": "Simulated multi-run plan: two nested runs. " + "The plan is included for testing purposes only.", + "parameters": { + "npts": { + "description": "The number of measurements in the outer run. " + "Inner run will contain 'npts+1' measurements.", + }, + "delay": { + "description": "Delay between measurements.", + }, + }, + } +) +def sim_multirun_plan_nested(npts: int, delay: float = 1.0): + for j in range(int(npts / 2)): + yield from bps.mov(motor, j * 0.2) + yield from bps.trigger_and_read([motor, det]) + yield from bps.sleep(delay) + + yield from _sim_plan_inner(npts + 1, delay) + + for j in range(int(npts / 2), npts): + yield from bps.mov(motor, j * 0.2) + yield from bps.trigger_and_read([motor, det]) + yield from bps.sleep(delay) + + +# ===================================================================================== +# Functions for testing 'function_execute' API. +# +# NOTE: those functions are used in unit tests. Changing the functions +# may cause those tests to fail. + + +def function_sleep(time): + """ + Sleep for a given number of seconds. + """ + print("******** Starting execution of the function 'function_sleep' **************") + print(f"******************* Waiting for {time} seconds **************************") + ttime.sleep(time) + print("******** Finished execution of the function 'function_sleep' **************") + + return {"success": True, "time": time} + + +_fifo_buffer = [] + + +def push_buffer_element(element): + """ + Push an element to a FIFO buffer. + """ + print("******** Executing the function 'push_buffer_element' **************") + _fifo_buffer.append(element) + + +def pop_buffer_element(): + """ + Pop an element from FIFO buffer. Raises exception if the buffer is empty + (function call fails, traceback should be returned). + """ + print("******** Executing the function 'pop_buffer_element' **************") + return _fifo_buffer.pop(0) + + +def clear_buffer(): + """ + The function used for testing of 'function_execute' API. + """ + print("******** Executing the function 'clear_buffer' **************") + return _fifo_buffer.clear() + + +# =========================================================================================== +# Simulated devices with subdevices. The devices are used in unit tests. Do not delete. +# If class names are changed, search and change the names in unit tests. +# Formatting of imported classes is inconsistent (e.g. 'Device', 'ophyd.Device' and +# 'ophyd.sim.SynAxis') is inconsistent on purpose to check if all possible versions work. + + +class SimStage(Device): + x = Cpt(ophyd.sim.SynAxis, name="y", labels={"motors"}) + y = Cpt(ophyd.sim.SynAxis, name="y", labels={"motors"}) + z = Cpt(ophyd.sim.SynAxis, name="z", labels={"motors"}) + + def set(self, x, y, z): + """Makes the device Movable""" + self.x.set(x) + self.y.set(y) + self.z.set(z) + + +class SimDetectors(Device): + """ + The detectors are controlled by simulated 'motor1' and 'motor2' + defined on the global scale. + """ + + det_A = Cpt( + ophyd.sim.SynGauss, + name="det_A", + motor=motor1, + motor_field="motor1", + center=0, + Imax=5, + sigma=0.5, + labels={"detectors"}, + ) + det_B = Cpt( + ophyd.sim.SynGauss, + name="det_B", + motor=motor2, + motor_field="motor2", + center=0, + Imax=5, + sigma=0.5, + labels={"detectors"}, + ) + + +class SimBundle(ophyd.Device): + mtrs = Cpt(SimStage, name="mtrs") + dets = Cpt(SimDetectors, name="dets") + + +sim_bundle_A = SimBundle(name="sim_bundle_A") +sim_bundle_B = SimBundle(name="sim_bundle_B") # Used for tests + + +@parameter_annotation_decorator( + { + "parameters": { + "detectors": { # Annotation for the parameter 'detectors' + "annotation": "typing.List[DetList]", + "devices": {"DetList": ["det", "det1", "det2", "det3", ":+^sim_bundle:?.*$"]}, + } + } + } +) +def count_bundle_test(detectors, num=1, delay=None, *, per_shot=None, md=None): + yield from count(detectors, num=num, delay=delay, per_shot=per_shot, md=md) + + +# ======================================================================================= +# Plans for testing visualization of Progress Bars + +from bluesky.utils import ProgressBar + + +class StatusPlaceholder: + "Just enough to make ProgressBar happy. We will update manually." + + def __init__(self): + self.done = False + + def watch(self, _): ... + + +def plan_test_progress_bars(n_progress_bars: int = 1): + """ + Test visualization of progress bars. + + Parameters + ---------- + n_progress_bars: int + The number of progress bars to display. + """ + # Display at least one progress bar + n_progress_bars = max(n_progress_bars, 1) + + # where the status object computes the fraction + st_list = [StatusPlaceholder() for _ in range(n_progress_bars)] + pbar = ProgressBar(st_list) + + v_min = 0 + v_max = 1 + + n_pts = 10 + step = (v_max - v_min) / n_pts + + print(f"TESTING {n_progress_bars} PROGRESS BARS ...\n") + + for n in range(n_pts): + yield from bps.sleep(0.5) + v = v_min + (n + 1) * step + for n_pb in range(n_progress_bars): + pbar.update(n_pb, name=f"TEST{n_pb + 1}", current=v, initial=v_min, target=v_max, fraction=n / n_pts) + + for st in st_list: + st.done = True + for n_pb in range(n_progress_bars): + pbar.update(n_pb, name=f"TEST{n_pb + 1}", current=1, initial=0, target=1, fraction=1) + + s = "\n" * n_progress_bars + print(f"{s}\nTEST COMPLETED ...") + + +# ======================================================================================= diff --git a/services/bluesky-services/ipython-profile/profile_collection_sim/startup/existing_plans_and_devices.yaml b/services/bluesky-services/ipython-profile/profile_collection_sim/startup/existing_plans_and_devices.yaml new file mode 100644 index 0000000000..d7fb832abc --- /dev/null +++ b/services/bluesky-services/ipython-profile/profile_collection_sim/startup/existing_plans_and_devices.yaml @@ -0,0 +1,3609 @@ +# This file is automatically generated. Edit at your own risk. +existing_devices: + ab_det: + classname: ABDetector + components: + a: + classname: SynSignal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.sim + b: + classname: SynSignal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.sim + is_flyable: false + is_movable: false + is_readable: true + module: ophyd.sim + bool_sig: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + custom_test_device: + classname: Device + is_flyable: false + is_movable: false + is_readable: true + module: ophyd.device + custom_test_flyer: + classname: MockFlyer + is_flyable: true + is_movable: false + is_readable: false + module: ophyd.sim + custom_test_signal: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + det: + classname: SynGauss + components: + Imax: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + center: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + noise: + classname: EnumSignal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.sim + noise_multiplier: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + sigma: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + val: + classname: SynSignal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.sim + is_flyable: false + is_movable: false + is_readable: true + module: ophyd.sim + det1: + classname: SynGauss + components: + Imax: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + center: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + noise: + classname: EnumSignal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.sim + noise_multiplier: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + sigma: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + val: + classname: SynSignal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.sim + is_flyable: false + is_movable: false + is_readable: true + module: ophyd.sim + det2: + classname: SynGauss + components: + Imax: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + center: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + noise: + classname: EnumSignal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.sim + noise_multiplier: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + sigma: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + val: + classname: SynSignal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.sim + is_flyable: false + is_movable: false + is_readable: true + module: ophyd.sim + det3: + classname: SynGauss + components: + Imax: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + center: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + noise: + classname: EnumSignal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.sim + noise_multiplier: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + sigma: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + val: + classname: SynSignal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.sim + is_flyable: false + is_movable: false + is_readable: true + module: ophyd.sim + det4: + classname: Syn2DGauss + components: + Imax: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + center: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + noise: + classname: EnumSignal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.sim + noise_multiplier: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + sigma: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + val: + classname: SynSignal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.sim + is_flyable: false + is_movable: false + is_readable: true + module: ophyd.sim + det5: + classname: Syn2DGauss + components: + Imax: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + center: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + noise: + classname: EnumSignal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.sim + noise_multiplier: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + sigma: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + val: + classname: SynSignal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.sim + is_flyable: false + is_movable: false + is_readable: true + module: ophyd.sim + det_with_conf: + classname: DetWithConf + components: + a: + classname: SynSignal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.sim + b: + classname: SynSignal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.sim + c: + classname: SynSignal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.sim + d: + classname: SynSignal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.sim + is_flyable: false + is_movable: false + is_readable: true + module: ophyd.sim + det_with_count_time: + classname: DetWithCountTime + components: + count_time: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + intensity: + classname: SynSignal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.sim + is_flyable: false + is_movable: false + is_readable: true + module: ophyd.sim + direct_img: + classname: DirectImage + components: + img: + classname: SynSignal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.sim + is_flyable: false + is_movable: false + is_readable: true + module: ophyd.sim + direct_img_list: + classname: DirectImage + components: + img: + classname: SynSignal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.sim + is_flyable: false + is_movable: false + is_readable: true + module: ophyd.sim + flyer1: + classname: MockFlyer + is_flyable: true + is_movable: false + is_readable: false + module: ophyd.sim + flyer2: + classname: MockFlyer + is_flyable: true + is_movable: false + is_readable: false + module: ophyd.sim + identical_det: + classname: SynGauss + components: + Imax: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + center: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + noise: + classname: EnumSignal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.sim + noise_multiplier: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + sigma: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + val: + classname: SynSignal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.sim + is_flyable: false + is_movable: false + is_readable: true + module: ophyd.sim + img: + classname: SynSignalWithRegistry + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.sim + invariant1: + classname: InvariantSignal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.sim + invariant2: + classname: InvariantSignal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.sim + jittery_motor1: + classname: SynAxis + components: + acceleration: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + readback: + classname: _ReadbackSignal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.sim + setpoint: + classname: _SetpointSignal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.sim + unused: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + velocity: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.sim + jittery_motor2: + classname: SynAxis + components: + acceleration: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + readback: + classname: _ReadbackSignal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.sim + setpoint: + classname: _SetpointSignal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.sim + unused: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + velocity: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.sim + motor: + classname: SynAxis + components: + acceleration: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + readback: + classname: _ReadbackSignal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.sim + setpoint: + classname: _SetpointSignal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.sim + unused: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + velocity: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.sim + motor1: + classname: SynAxis + components: + acceleration: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + readback: + classname: _ReadbackSignal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.sim + setpoint: + classname: _SetpointSignal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.sim + unused: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + velocity: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.sim + motor2: + classname: SynAxis + components: + acceleration: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + readback: + classname: _ReadbackSignal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.sim + setpoint: + classname: _SetpointSignal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.sim + unused: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + velocity: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.sim + motor3: + classname: SynAxis + components: + acceleration: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + readback: + classname: _ReadbackSignal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.sim + setpoint: + classname: _SetpointSignal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.sim + unused: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + velocity: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.sim + motor_empty_hints1: + classname: SynAxisEmptyHints + components: + acceleration: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + readback: + classname: _ReadbackSignal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.sim + setpoint: + classname: _SetpointSignal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.sim + unused: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + velocity: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.sim + motor_empty_hints2: + classname: SynAxisEmptyHints + components: + acceleration: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + readback: + classname: _ReadbackSignal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.sim + setpoint: + classname: _SetpointSignal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.sim + unused: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + velocity: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.sim + motor_no_hints1: + classname: SynAxisNoHints + components: + acceleration: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + readback: + classname: _ReadbackSignal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.sim + setpoint: + classname: _SetpointSignal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.sim + unused: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + velocity: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.sim + motor_no_hints2: + classname: SynAxisNoHints + components: + acceleration: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + readback: + classname: _ReadbackSignal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.sim + setpoint: + classname: _SetpointSignal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.sim + unused: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + velocity: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.sim + motor_no_pos: + classname: SynAxisNoPosition + components: + acceleration: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + readback: + classname: _ReadbackSignal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.sim + setpoint: + classname: _SetpointSignal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.sim + unused: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + velocity: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.sim + new_trivial_flyer: + classname: NewTrivialFlyer + is_flyable: true + is_movable: false + is_readable: false + module: ophyd.sim + noisy_det: + classname: SynGauss + components: + Imax: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + center: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + noise: + classname: EnumSignal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.sim + noise_multiplier: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + sigma: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + val: + classname: SynSignal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.sim + is_flyable: false + is_movable: false + is_readable: true + module: ophyd.sim + pseudo1x3: + classname: SPseudo1x3 + components: + pseudo1: + classname: PseudoSingle + components: + readback: + classname: AttributeSignal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + setpoint: + classname: AttributeSignal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.pseudopos + real1: + classname: SoftPositioner + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.positioner + real2: + classname: SoftPositioner + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.positioner + real3: + classname: SoftPositioner + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.positioner + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.sim + pseudo3x3: + classname: SPseudo3x3 + components: + pseudo1: + classname: PseudoSingle + components: + readback: + classname: AttributeSignal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + setpoint: + classname: AttributeSignal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.pseudopos + pseudo2: + classname: PseudoSingle + components: + readback: + classname: AttributeSignal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + setpoint: + classname: AttributeSignal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.pseudopos + pseudo3: + classname: PseudoSingle + components: + readback: + classname: AttributeSignal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + setpoint: + classname: AttributeSignal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.pseudopos + real1: + classname: SoftPositioner + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.positioner + real2: + classname: SoftPositioner + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.positioner + real3: + classname: SoftPositioner + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.positioner + sig: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.sim + rand: + classname: SynPeriodicSignal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.sim + rand2: + classname: SynPeriodicSignal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.sim + sig: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + signal: + classname: SynSignal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.sim + sim_bundle_A: + classname: SimBundle + components: + dets: + classname: SimDetectors + components: + det_A: + classname: SynGauss + components: + Imax: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + center: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + noise: + classname: EnumSignal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.sim + noise_multiplier: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + sigma: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + val: + classname: SynSignal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.sim + is_flyable: false + is_movable: false + is_readable: true + module: ophyd.sim + det_B: + classname: SynGauss + components: + Imax: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + center: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + noise: + classname: EnumSignal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.sim + noise_multiplier: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + sigma: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + val: + classname: SynSignal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.sim + is_flyable: false + is_movable: false + is_readable: true + module: ophyd.sim + is_flyable: false + is_movable: false + is_readable: true + module: __main__ + mtrs: + classname: SimStage + components: + x: + classname: SynAxis + components: + acceleration: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + readback: + classname: _ReadbackSignal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.sim + setpoint: + classname: _SetpointSignal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.sim + unused: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + velocity: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.sim + y: + classname: SynAxis + components: + acceleration: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + readback: + classname: _ReadbackSignal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.sim + setpoint: + classname: _SetpointSignal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.sim + unused: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + velocity: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.sim + z: + classname: SynAxis + components: + acceleration: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + readback: + classname: _ReadbackSignal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.sim + setpoint: + classname: _SetpointSignal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.sim + unused: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + velocity: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.sim + is_flyable: false + is_movable: true + is_readable: true + module: __main__ + is_flyable: false + is_movable: false + is_readable: true + module: __main__ + sim_bundle_B: + classname: SimBundle + components: + dets: + classname: SimDetectors + components: + det_A: + classname: SynGauss + components: + Imax: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + center: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + noise: + classname: EnumSignal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.sim + noise_multiplier: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + sigma: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + val: + classname: SynSignal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.sim + is_flyable: false + is_movable: false + is_readable: true + module: ophyd.sim + det_B: + classname: SynGauss + components: + Imax: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + center: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + noise: + classname: EnumSignal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.sim + noise_multiplier: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + sigma: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + val: + classname: SynSignal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.sim + is_flyable: false + is_movable: false + is_readable: true + module: ophyd.sim + is_flyable: false + is_movable: false + is_readable: true + module: __main__ + mtrs: + classname: SimStage + components: + x: + classname: SynAxis + components: + acceleration: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + readback: + classname: _ReadbackSignal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.sim + setpoint: + classname: _SetpointSignal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.sim + unused: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + velocity: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.sim + y: + classname: SynAxis + components: + acceleration: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + readback: + classname: _ReadbackSignal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.sim + setpoint: + classname: _SetpointSignal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.sim + unused: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + velocity: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.sim + z: + classname: SynAxis + components: + acceleration: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + readback: + classname: _ReadbackSignal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.sim + setpoint: + classname: _SetpointSignal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.sim + unused: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + velocity: + classname: Signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.signal + is_flyable: false + is_movable: true + is_readable: true + module: ophyd.sim + is_flyable: false + is_movable: true + is_readable: true + module: __main__ + is_flyable: false + is_movable: false + is_readable: true + module: __main__ + trivial_flyer: + classname: TrivialFlyer + is_flyable: true + is_movable: false + is_readable: false + module: ophyd.sim +existing_plans: + _sim_plan_inner: + module: __main__ + name: _sim_plan_inner + parameters: + - annotation: + type: int + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: npts + - annotation: + type: float + default: '1.0' + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: delay + properties: + is_generator: true + adaptive_scan: + description: Scan over one variable with adaptively tuned step size. + module: bluesky.plans + name: adaptive_scan + parameters: + - annotation: + type: collections.abc.Sequence[__READABLE__] + convert_device_names: true + description: list of 'readable' objects + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: detectors + - annotation: + type: str + description: data field whose output is the focus of the adaptive tuning + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: target_field + - annotation: + type: __MOVABLE__ + convert_device_names: true + description: any 'settable' object (motor, temp controller, etc.) + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: motor + - annotation: + type: float + description: starting position of motor + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: start + - annotation: + type: float + description: ending position of motor + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: stop + - annotation: + type: float + description: smallest step for fast-changing regions + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: min_step + - annotation: + type: float + description: largest step for slow-changing regions + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: max_step + - annotation: + type: float + description: desired fractional change in detector signal between steps + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: target_delta + - annotation: + type: bool + description: whether backward steps are allowed -- this is concern with some + motors + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: backstep + - annotation: + type: typing.Optional[float] + default: '0.8' + description: threshold for going backward and rescanning a region, default is + 0.8 + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: threshold + - annotation: + type: typing.Optional[dict[str, typing.Any]] + default: None + description: metadata + kind: + name: KEYWORD_ONLY + value: 3 + name: md + properties: + is_generator: true + count: + description: Take one or more readings from detectors. + module: bluesky.plans + name: count + parameters: + - annotation: + type: collections.abc.Sequence[__READABLE__] + convert_device_names: true + description: list of 'readable' objects + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: detectors + - annotation: + type: typing.Optional[int] + default: '1' + description: 'number of readings to take; default is 1 + + + If None, capture data until canceled' + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: num + - annotation: + type: typing.Union[float, collections.abc.Iterable[float]] + default: '0.0' + description: Time delay in seconds between successive readings; default is 0. + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: delay + - default: None + description: "hook for customizing action of inner loop (messages per step)\n\ + Expected signature ::\n\n def f(detectors: Iterable[OphydObj]) -> Generator[Msg]:\n\ + \ ..." + kind: + name: KEYWORD_ONLY + value: 3 + name: per_shot + - annotation: + type: typing.Optional[dict[str, typing.Any]] + default: None + description: metadata + kind: + name: KEYWORD_ONLY + value: 3 + name: md + properties: + is_generator: true + count_bundle_test: + module: __main__ + name: count_bundle_test + parameters: + - annotation: + devices: + DetList: + - det + - det1 + - det2 + - det3 + - sim_bundle_A + - sim_bundle_A.dets + - sim_bundle_A.dets.det_A + - sim_bundle_A.dets.det_A.center + - sim_bundle_A.dets.det_A.Imax + - sim_bundle_A.dets.det_A.noise + - sim_bundle_A.dets.det_A.noise_multiplier + - sim_bundle_A.dets.det_A.sigma + - sim_bundle_A.dets.det_A.val + - sim_bundle_A.dets.det_B + - sim_bundle_A.dets.det_B.center + - sim_bundle_A.dets.det_B.Imax + - sim_bundle_A.dets.det_B.noise + - sim_bundle_A.dets.det_B.noise_multiplier + - sim_bundle_A.dets.det_B.sigma + - sim_bundle_A.dets.det_B.val + - sim_bundle_A.mtrs + - sim_bundle_A.mtrs.x + - sim_bundle_A.mtrs.x.acceleration + - sim_bundle_A.mtrs.x.readback + - sim_bundle_A.mtrs.x.setpoint + - sim_bundle_A.mtrs.x.unused + - sim_bundle_A.mtrs.x.velocity + - sim_bundle_A.mtrs.y + - sim_bundle_A.mtrs.y.acceleration + - sim_bundle_A.mtrs.y.readback + - sim_bundle_A.mtrs.y.setpoint + - sim_bundle_A.mtrs.y.unused + - sim_bundle_A.mtrs.y.velocity + - sim_bundle_A.mtrs.z + - sim_bundle_A.mtrs.z.acceleration + - sim_bundle_A.mtrs.z.readback + - sim_bundle_A.mtrs.z.setpoint + - sim_bundle_A.mtrs.z.unused + - sim_bundle_A.mtrs.z.velocity + - sim_bundle_B + - sim_bundle_B.dets + - sim_bundle_B.dets.det_A + - sim_bundle_B.dets.det_A.center + - sim_bundle_B.dets.det_A.Imax + - sim_bundle_B.dets.det_A.noise + - sim_bundle_B.dets.det_A.noise_multiplier + - sim_bundle_B.dets.det_A.sigma + - sim_bundle_B.dets.det_A.val + - sim_bundle_B.dets.det_B + - sim_bundle_B.dets.det_B.center + - sim_bundle_B.dets.det_B.Imax + - sim_bundle_B.dets.det_B.noise + - sim_bundle_B.dets.det_B.noise_multiplier + - sim_bundle_B.dets.det_B.sigma + - sim_bundle_B.dets.det_B.val + - sim_bundle_B.mtrs + - sim_bundle_B.mtrs.x + - sim_bundle_B.mtrs.x.acceleration + - sim_bundle_B.mtrs.x.readback + - sim_bundle_B.mtrs.x.setpoint + - sim_bundle_B.mtrs.x.unused + - sim_bundle_B.mtrs.x.velocity + - sim_bundle_B.mtrs.y + - sim_bundle_B.mtrs.y.acceleration + - sim_bundle_B.mtrs.y.readback + - sim_bundle_B.mtrs.y.setpoint + - sim_bundle_B.mtrs.y.unused + - sim_bundle_B.mtrs.y.velocity + - sim_bundle_B.mtrs.z + - sim_bundle_B.mtrs.z.acceleration + - sim_bundle_B.mtrs.z.readback + - sim_bundle_B.mtrs.z.setpoint + - sim_bundle_B.mtrs.z.unused + - sim_bundle_B.mtrs.z.velocity + type: typing.List[DetList] + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: detectors + - default: '1' + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: num + - default: None + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: delay + - default: None + kind: + name: KEYWORD_ONLY + value: 3 + name: per_shot + - default: None + kind: + name: KEYWORD_ONLY + value: 3 + name: md + properties: + is_generator: true + fly: + description: Perform a fly scan with one or more 'flyers'. + module: bluesky.plans + name: fly + parameters: + - annotation: + type: list[__FLYABLE__] + convert_device_names: true + description: objects that support the flyer interface + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: flyers + - annotation: + type: typing.Optional[dict[str, typing.Any]] + default: None + description: metadata + kind: + name: KEYWORD_ONLY + value: 3 + name: md + properties: + is_generator: true + grid_scan: + description: Scan over a mesh; each motor is on an independent trajectory. + module: bluesky.plans + name: grid_scan + parameters: + - annotation: + type: collections.abc.Sequence[__READABLE__] + convert_device_names: true + description: list of 'readable' objects + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: detectors + - kind: + name: VAR_POSITIONAL + value: 2 + name: args + - annotation: + type: typing.Union[collections.abc.Iterable[typing.Any], bool, NoneType] + default: None + description: 'which axes should be snaked, either ``False`` (do not snake any + axes), + + ``True`` (snake all axes) or a list of axes to snake. "Snaking" an axis + + is defined as following snake-like, winding trajectory instead of a + + simple left-to-right trajectory. The elements of the list are motors + + that are listed in `args`. The list must not contain the slowest + + (first) motor, since it can''t be snaked.' + kind: + name: KEYWORD_ONLY + value: 3 + name: snake_axes + - default: None + description: 'hook for customizing action of inner loop (messages per step). + + See docstring of :func:`bluesky.plan_stubs.one_nd_step` (the default) + + for details.' + kind: + name: KEYWORD_ONLY + value: 3 + name: per_step + - annotation: + type: typing.Optional[dict[str, typing.Any]] + default: None + description: metadata + kind: + name: KEYWORD_ONLY + value: 3 + name: md + properties: + is_generator: true + inner_product_scan: + module: bluesky.plans + name: inner_product_scan + parameters: + - annotation: + type: collections.abc.Sequence[__READABLE__] + convert_device_names: true + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: detectors + - annotation: + type: int + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: num + - annotation: + type: typing.Union[__MOVABLE__, typing.Any] + convert_device_names: true + kind: + name: VAR_POSITIONAL + value: 2 + name: args + - default: None + kind: + name: KEYWORD_ONLY + value: 3 + name: per_step + - annotation: + type: typing.Optional[dict[str, typing.Any]] + default: None + kind: + name: KEYWORD_ONLY + value: 3 + name: md + properties: + is_generator: true + list_grid_scan: + description: Scan over a mesh; each motor is on an independent trajectory. + module: bluesky.plans + name: list_grid_scan + parameters: + - annotation: + type: collections.abc.Sequence[__READABLE__] + convert_device_names: true + description: list of 'readable' objects + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: detectors + - annotation: + type: typing.Union[__MOVABLE__, typing.Any] + convert_device_names: true + description: "patterned like (``motor1, position_list1,``\n ``motor2,\ + \ position_list2,``\n ``motor3, position_list3,``\n \ + \ ``...,``\n ``motorN, position_listN``)\n\nThe first\ + \ motor is the \"slowest\", the outer loop. ``position_list``'s\nare lists\ + \ of positions, all lists must have the same length. Motors\ncan be any 'settable'\ + \ object (motor, temp controller, etc.)." + kind: + name: VAR_POSITIONAL + value: 2 + name: args + - annotation: + type: bool + default: 'False' + description: 'which axes should be snaked, either ``False`` (do not snake any + axes), + + ``True`` (snake all axes) or a list of axes to snake. "Snaking" an axis + + is defined as following snake-like, winding trajectory instead of a + + simple left-to-right trajectory.The elements of the list are motors + + that are listed in `args`. The list must not contain the slowest + + (first) motor, since it can''t be snaked.' + kind: + name: KEYWORD_ONLY + value: 3 + name: snake_axes + - default: None + description: 'hook for customizing action of inner loop (messages per step). + + See docstring of :func:`bluesky.plan_stubs.one_nd_step` (the default) + + for details.' + kind: + name: KEYWORD_ONLY + value: 3 + name: per_step + - annotation: + type: typing.Optional[dict[str, typing.Any]] + default: None + description: metadata + kind: + name: KEYWORD_ONLY + value: 3 + name: md + properties: + is_generator: true + list_scan: + description: Scan over one or more variables in steps simultaneously (inner product). + module: bluesky.plans + name: list_scan + parameters: + - annotation: + type: collections.abc.Sequence[__READABLE__] + convert_device_names: true + description: list of 'readable' objects + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: detectors + - annotation: + type: tuple[typing.Union[__MOVABLE__, typing.Any], list[typing.Any]] + convert_device_names: true + description: "For one dimension, ``motor, [point1, point2, ....]``.\nIn general:\n\ + \n.. code-block:: python\n\n motor1, [point1, point2, ...],\n motor2,\ + \ [point1, point2, ...],\n ...,\n motorN, [point1, point2, ...]\n\n\ + Motors can be any 'settable' object (motor, temp controller, etc.)" + kind: + name: VAR_POSITIONAL + value: 2 + name: args + - default: None + description: 'hook for customizing action of inner loop (messages per step) + + Expected signature: + + ``f(detectors, motor, step) -> plan (a generator)``' + kind: + name: KEYWORD_ONLY + value: 3 + name: per_step + - annotation: + type: typing.Optional[dict[str, typing.Any]] + default: None + description: metadata + kind: + name: KEYWORD_ONLY + value: 3 + name: md + properties: + is_generator: true + log_scan: + description: Scan over one variable in log-spaced steps. + module: bluesky.plans + name: log_scan + parameters: + - annotation: + type: collections.abc.Sequence[__READABLE__] + convert_device_names: true + description: list of 'readable' objects + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: detectors + - annotation: + type: __MOVABLE__ + convert_device_names: true + description: any 'settable' object (motor, temp controller, etc.) + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: motor + - annotation: + type: float + description: starting position of motor + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: start + - annotation: + type: float + description: ending position of motor + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: stop + - annotation: + type: int + description: number of steps + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: num + - default: None + description: 'hook for customizing action of inner loop (messages per step) + + Expected signature: ``f(detectors, motor, step)``' + kind: + name: KEYWORD_ONLY + value: 3 + name: per_step + - default: None + description: metadata + kind: + name: KEYWORD_ONLY + value: 3 + name: md + properties: + is_generator: true + marked_up_count: + module: __main__ + name: marked_up_count + parameters: + - annotation: + type: typing.List[typing.Any] + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: detectors + - annotation: + type: int + default: '1' + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: num + - annotation: + type: typing.Optional[float] + default: None + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: delay + - annotation: + type: typing.Optional[typing.Dict[str, typing.Any]] + default: None + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: md + properties: + is_generator: true + move_then_count: + description: Move motors into positions; then count dets. + module: __main__ + name: move_then_count + parameters: + - annotation: + devices: + Motors: + - motor1 + - motor2 + type: typing.List[Motors] + description: List of motors to be moved into specified positions before the + measurement + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: motors + - annotation: + devices: + Detectors: + - det1 + - det2 + - det3 + type: typing.List[Detectors] + default: '[''det1'', ''det2'']' + default_defined_in_decorator: true + description: Detectors to use for measurement. + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: detectors + - annotation: + type: typing.List[float] + default: None + description: Motor positions. The number of positions must be equal to the number + of the motors. + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + max: '10' + min: '-10' + name: positions + step: '0.01' + properties: + is_generator: true + mv: + description: Move one or more devices to a setpoint. Wait for all to complete. + module: bluesky.plan_stubs + name: mv + parameters: + - annotation: + type: typing.Union[__MOVABLE__, typing.Any] + convert_device_names: true + description: device1, value1, device2, value2, ... + kind: + name: VAR_POSITIONAL + value: 2 + name: args + - annotation: + type: typing.Optional[collections.abc.Hashable] + default: None + description: Used to mark these as a unit to be waited on. + kind: + name: KEYWORD_ONLY + value: 3 + name: group + - annotation: + type: typing.Optional[float] + default: None + description: Specify a maximum time that the move(s) can be waited for. + kind: + name: KEYWORD_ONLY + value: 3 + name: timeout + - description: passed to obj.set() + kind: + name: VAR_KEYWORD + value: 4 + name: kwargs + properties: + is_generator: false + mvr: + description: Move one or more devices to a relative setpoint. Wait for all to + complete. + module: bluesky.plan_stubs + name: mvr + parameters: + - annotation: + type: typing.Union[__MOVABLE__, typing.Any] + convert_device_names: true + description: device1, value1, device2, value2, ... + kind: + name: VAR_POSITIONAL + value: 2 + name: args + - annotation: + type: typing.Optional[collections.abc.Hashable] + default: None + description: Used to mark these as a unit to be waited on. + kind: + name: KEYWORD_ONLY + value: 3 + name: group + - annotation: + type: typing.Optional[float] + default: None + description: Specify a maximum time that the move(s) can be waited for. + kind: + name: KEYWORD_ONLY + value: 3 + name: timeout + - description: passed to obj.set() + kind: + name: VAR_KEYWORD + value: 4 + name: kwargs + properties: + is_generator: false + 'null': + description: Yield a no-op Message. (Primarily for debugging and testing.) + module: bluesky.plan_stubs + name: 'null' + parameters: [] + properties: + is_generator: false + plan_test_progress_bars: + description: Test visualization of progress bars. + module: __main__ + name: plan_test_progress_bars + parameters: + - annotation: + type: int + default: '1' + description: The number of progress bars to display. + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: n_progress_bars + properties: + is_generator: true + ramp_plan: + description: Take data while ramping one or more positioners. + module: bluesky.plans + name: ramp_plan + parameters: + - description: 'plan to start the ramp. This will be run inside of a open/close + + run. + + + This plan must return a `ophyd.StatusBase` object.' + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: go_plan + - annotation: + type: __READABLE__ + convert_device_names: true + description: signal to be monitored + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: monitor_sig + - description: 'generator which takes no input + + + This will be called for every data point. This should create + + one or more events.' + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: inner_plan_func + - annotation: + type: bool + default: 'True' + description: If True, add a pre data at beginning + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: take_pre_data + - annotation: + type: typing.Optional[float] + default: None + description: 'If not None, the maximum time the ramp can run. + + + In seconds' + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: timeout + - annotation: + type: typing.Optional[float] + default: None + description: 'If not None, take data no faster than this. If None, take + + data as fast as possible + + + If running the inner plan takes longer than `period` than take + + data with no dead time. + + + In seconds.' + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: period + - annotation: + type: typing.Optional[dict[str, typing.Any]] + default: None + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: md + properties: + is_generator: true + rel_adaptive_scan: + description: Relative scan over one variable with adaptively tuned step size. + module: bluesky.plans + name: rel_adaptive_scan + parameters: + - annotation: + type: collections.abc.Sequence[__READABLE__] + convert_device_names: true + description: list of 'readable' objects + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: detectors + - annotation: + type: str + description: data field whose output is the focus of the adaptive tuning + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: target_field + - annotation: + type: __MOVABLE__ + convert_device_names: true + description: any 'settable' object (motor, temp controller, etc.) + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: motor + - annotation: + type: float + description: starting position of motor, relative to the current position. + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: start + - annotation: + type: float + description: ending position of motor, relative to the current position. + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: stop + - annotation: + type: float + description: smallest step for fast-changing regions + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: min_step + - annotation: + type: float + description: largest step for slow-changing regions + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: max_step + - annotation: + type: float + description: desired fractional change in detector signal between steps + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: target_delta + - annotation: + type: bool + description: whether backward steps are allowed -- this is concern with some + motors + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: backstep + - annotation: + type: typing.Optional[float] + default: '0.8' + description: threshold for going backward and rescanning a region, default is + 0.8 + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: threshold + - annotation: + type: typing.Optional[dict[str, typing.Any]] + default: None + description: metadata + kind: + name: KEYWORD_ONLY + value: 3 + name: md + properties: + is_generator: true + rel_grid_scan: + description: Scan over a mesh relative to current position. + module: bluesky.plans + name: rel_grid_scan + parameters: + - annotation: + type: collections.abc.Sequence[__READABLE__] + convert_device_names: true + description: list of 'readable' objects + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: detectors + - annotation: + type: typing.Union[__MOVABLE__, typing.Any] + convert_device_names: true + kind: + name: VAR_POSITIONAL + value: 2 + name: args + - annotation: + type: typing.Union[collections.abc.Iterable[typing.Any], bool, NoneType] + default: None + description: 'which axes should be snaked, either ``False`` (do not snake any + axes), + + ``True`` (snake all axes) or a list of axes to snake. "Snaking" an axis + + is defined as following snake-like, winding trajectory instead of a + + simple left-to-right trajectory. The elements of the list are motors + + that are listed in `args`. The list must not contain the slowest + + (first) motor, since it can''t be snaked.' + kind: + name: KEYWORD_ONLY + value: 3 + name: snake_axes + - default: None + description: 'hook for customizing action of inner loop (messages per step). + + See docstring of :func:`bluesky.plan_stubs.one_nd_step` (the default) + + for details.' + kind: + name: KEYWORD_ONLY + value: 3 + name: per_step + - annotation: + type: typing.Optional[dict[str, typing.Any]] + default: None + description: metadata + kind: + name: KEYWORD_ONLY + value: 3 + name: md + properties: + is_generator: true + rel_list_grid_scan: + description: 'Scan over a mesh; each motor is on an independent trajectory. Each + point is + + relative to the current position.' + module: bluesky.plans + name: rel_list_grid_scan + parameters: + - annotation: + type: collections.abc.Sequence[__READABLE__] + convert_device_names: true + description: list of 'readable' objects + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: detectors + - annotation: + type: typing.Union[__MOVABLE__, typing.Any] + convert_device_names: true + description: "patterned like (``motor1, position_list1,``\n ``motor2,\ + \ position_list2,``\n ``motor3, position_list3,``\n \ + \ ``...,``\n ``motorN, position_listN``)\n\nThe first\ + \ motor is the \"slowest\", the outer loop. ``position_list``'s\nare lists\ + \ of positions, all lists must have the same length. Motors\ncan be any 'settable'\ + \ object (motor, temp controller, etc.)." + kind: + name: VAR_POSITIONAL + value: 2 + name: args + - annotation: + type: bool + default: 'False' + description: 'which axes should be snaked, either ``False`` (do not snake any + axes), + + ``True`` (snake all axes) or a list of axes to snake. "Snaking" an axis + + is defined as following snake-like, winding trajectory instead of a + + simple left-to-right trajectory.The elements of the list are motors + + that are listed in `args`. The list must not contain the slowest + + (first) motor, since it can''t be snaked.' + kind: + name: KEYWORD_ONLY + value: 3 + name: snake_axes + - default: None + description: 'hook for customizing action of inner loop (messages per step). + + See docstring of :func:`bluesky.plan_stubs.one_nd_step` (the default) + + for details.' + kind: + name: KEYWORD_ONLY + value: 3 + name: per_step + - annotation: + type: typing.Optional[dict[str, typing.Any]] + default: None + description: metadata + kind: + name: KEYWORD_ONLY + value: 3 + name: md + properties: + is_generator: true + rel_list_scan: + description: Scan over one variable in steps relative to current position. + module: bluesky.plans + name: rel_list_scan + parameters: + - annotation: + type: collections.abc.Sequence[__READABLE__] + convert_device_names: true + description: list of 'readable' objects + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: detectors + - annotation: + type: typing.Union[__MOVABLE__, typing.Any] + convert_device_names: true + description: "For one dimension, ``motor, [point1, point2, ....]``.\nIn general:\n\ + \n.. code-block:: python\n\n motor1, [point1, point2, ...],\n motor2,\ + \ [point1, point2, ...],\n ...,\n motorN, [point1, point2, ...]\n\n\ + Motors can be any 'settable' object (motor, temp controller, etc.)\npoint1,\ + \ point2 etc are relative to the current location." + kind: + name: VAR_POSITIONAL + value: 2 + name: args + - default: None + description: 'hook for customizing action of inner loop (messages per step) + + Expected signature: ``f(detectors, motor, step)``' + kind: + name: KEYWORD_ONLY + value: 3 + name: per_step + - annotation: + type: typing.Optional[dict[str, typing.Any]] + default: None + description: metadata + kind: + name: KEYWORD_ONLY + value: 3 + name: md + properties: + is_generator: true + rel_log_scan: + description: Scan over one variable in log-spaced steps relative to current position. + module: bluesky.plans + name: rel_log_scan + parameters: + - annotation: + type: collections.abc.Sequence[__READABLE__] + convert_device_names: true + description: list of 'readable' objects + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: detectors + - annotation: + type: __MOVABLE__ + convert_device_names: true + description: any 'settable' object (motor, temp controller, etc.) + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: motor + - annotation: + type: float + description: starting position of motor + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: start + - annotation: + type: float + description: ending position of motor + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: stop + - annotation: + type: int + description: number of steps + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: num + - default: None + description: 'hook for customizing action of inner loop (messages per step) + + Expected signature: ``f(detectors, motor, step)``' + kind: + name: KEYWORD_ONLY + value: 3 + name: per_step + - annotation: + type: typing.Optional[dict[str, typing.Any]] + default: None + description: metadata + kind: + name: KEYWORD_ONLY + value: 3 + name: md + properties: + is_generator: true + rel_scan: + description: Scan over one multi-motor trajectory relative to current position. + module: bluesky.plans + name: rel_scan + parameters: + - annotation: + type: collections.abc.Sequence[__READABLE__] + convert_device_names: true + description: list of 'readable' objects + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: detectors + - annotation: + type: typing.Union[__MOVABLE__, typing.Any] + convert_device_names: true + description: "For one dimension, ``motor, start, stop``.\nIn general:\n\n..\ + \ code-block:: python\n\n motor1, start1, stop1,\n motor2, start2, start2,\n\ + \ ...,\n motorN, startN, stopN,\n\nMotors can be any 'settable' object\ + \ (motor, temp controller, etc.)" + kind: + name: VAR_POSITIONAL + value: 2 + name: args + - default: None + description: number of points + kind: + name: KEYWORD_ONLY + value: 3 + name: num + - default: None + description: 'hook for customizing action of inner loop (messages per step). + + See docstring of :func:`bluesky.plan_stubs.one_nd_step` (the default) + + for details.' + kind: + name: KEYWORD_ONLY + value: 3 + name: per_step + - annotation: + type: typing.Optional[dict[str, typing.Any]] + default: None + description: metadata + kind: + name: KEYWORD_ONLY + value: 3 + name: md + properties: + is_generator: true + rel_spiral: + description: Relative spiral scan + module: bluesky.plans + name: rel_spiral + parameters: + - annotation: + type: collections.abc.Sequence[__READABLE__] + convert_device_names: true + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: detectors + - annotation: + type: __MOVABLE__ + convert_device_names: true + description: any 'settable' object (motor, temp controller, etc.) + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: x_motor + - annotation: + type: __MOVABLE__ + convert_device_names: true + description: any 'settable' object (motor, temp controller, etc.) + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: y_motor + - annotation: + type: float + description: x width of spiral + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: x_range + - annotation: + type: float + description: y width of spiral + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: y_range + - annotation: + type: float + description: Delta radius along the minor axis of the ellipse. + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: dr + - annotation: + type: float + description: Number of theta steps + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: nth + - annotation: + type: typing.Optional[float] + default: None + description: 'Delta radius along the major axis of the ellipse. If None, it + + defaults to dr.' + kind: + name: KEYWORD_ONLY + value: 3 + name: dr_y + - annotation: + type: float + default: '0.0' + description: Tilt angle in radians, default 0.0 + kind: + name: KEYWORD_ONLY + value: 3 + name: tilt + - default: None + description: 'hook for customizing action of inner loop (messages per step). + + See docstring of :func:`bluesky.plan_stubs.one_nd_step` (the default) + + for details.' + kind: + name: KEYWORD_ONLY + value: 3 + name: per_step + - annotation: + type: typing.Optional[dict[str, typing.Any]] + default: None + description: metadata + kind: + name: KEYWORD_ONLY + value: 3 + name: md + properties: + is_generator: true + rel_spiral_fermat: + description: Relative fermat spiral scan + module: bluesky.plans + name: rel_spiral_fermat + parameters: + - annotation: + type: collections.abc.Sequence[__READABLE__] + convert_device_names: true + description: list of 'readable' objects + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: detectors + - annotation: + type: __MOVABLE__ + convert_device_names: true + description: any 'settable' object (motor, temp controller, etc.) + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: x_motor + - annotation: + type: __MOVABLE__ + convert_device_names: true + description: any 'settable' object (motor, temp controller, etc.) + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: y_motor + - annotation: + type: float + description: x width of spiral + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: x_range + - annotation: + type: float + description: y width of spiral + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: y_range + - annotation: + type: float + description: delta radius + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: dr + - annotation: + type: float + description: radius gets divided by this + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: factor + - annotation: + type: typing.Optional[float] + default: None + description: 'Delta radius along the major axis of the ellipse, if not specifed + + defaults to dr' + kind: + name: KEYWORD_ONLY + value: 3 + name: dr_y + - annotation: + type: typing.Optional[float] + default: '0.0' + description: Tilt angle in radians, default 0.0 + kind: + name: KEYWORD_ONLY + value: 3 + name: tilt + - default: None + description: 'hook for customizing action of inner loop (messages per step). + + See docstring of :func:`bluesky.plan_stubs.one_nd_step` (the default) + + for details.' + kind: + name: KEYWORD_ONLY + value: 3 + name: per_step + - annotation: + type: typing.Optional[dict[str, typing.Any]] + default: None + description: metadata + kind: + name: KEYWORD_ONLY + value: 3 + name: md + properties: + is_generator: true + rel_spiral_square: + description: Relative square spiral scan, centered around current (x, y) position. + module: bluesky.plans + name: rel_spiral_square + parameters: + - annotation: + type: collections.abc.Sequence[__READABLE__] + convert_device_names: true + description: list of 'readable' objects + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: detectors + - annotation: + type: __MOVABLE__ + convert_device_names: true + description: any 'settable' object (motor, temp controller, etc.) + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: x_motor + - annotation: + type: __MOVABLE__ + convert_device_names: true + description: any 'settable' object (motor, temp controller, etc.) + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: y_motor + - annotation: + type: float + description: x width of spiral + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: x_range + - annotation: + type: float + description: y width of spiral + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: y_range + - annotation: + type: float + description: number of x axis points + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: x_num + - annotation: + type: float + description: Number of y axis points. + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: y_num + - default: None + description: 'hook for cutomizing action of inner loop (messages per step). + + See docstring of :func:`bluesky.plans.one_nd_step` (the default) for + + details.' + kind: + name: KEYWORD_ONLY + value: 3 + name: per_step + - annotation: + type: typing.Optional[dict[str, typing.Any]] + default: None + description: metadata + kind: + name: KEYWORD_ONLY + value: 3 + name: md + properties: + is_generator: true + relative_inner_product_scan: + module: bluesky.plans + name: relative_inner_product_scan + parameters: + - annotation: + type: collections.abc.Sequence[__READABLE__] + convert_device_names: true + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: detectors + - annotation: + type: int + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: num + - annotation: + type: typing.Union[__MOVABLE__, typing.Any] + convert_device_names: true + kind: + name: VAR_POSITIONAL + value: 2 + name: args + - default: None + kind: + name: KEYWORD_ONLY + value: 3 + name: per_step + - annotation: + type: typing.Optional[dict[str, typing.Any]] + default: None + kind: + name: KEYWORD_ONLY + value: 3 + name: md + properties: + is_generator: true + scan: + description: Scan over one multi-motor trajectory. + module: bluesky.plans + name: scan + parameters: + - annotation: + type: collections.abc.Sequence[__READABLE__] + convert_device_names: true + description: list of 'readable' objects + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: detectors + - annotation: + type: typing.Union[__MOVABLE__, typing.Any] + convert_device_names: true + description: "For one dimension, ``motor, start, stop``.\nIn general:\n\n..\ + \ code-block:: python\n\n motor1, start1, stop1,\n motor2, start2, stop2,\n\ + \ ...,\n motorN, startN, stopN\n\nMotors can be any 'settable' object\ + \ (motor, temp controller, etc.)" + kind: + name: VAR_POSITIONAL + value: 2 + name: args + - annotation: + type: typing.Optional[int] + default: None + description: number of points + kind: + name: KEYWORD_ONLY + value: 3 + name: num + - default: None + description: 'hook for customizing action of inner loop (messages per step). + + See docstring of :func:`bluesky.plan_stubs.one_nd_step` (the default) + + for details.' + kind: + name: KEYWORD_ONLY + value: 3 + name: per_step + - annotation: + type: typing.Optional[dict[str, typing.Any]] + default: None + description: metadata + kind: + name: KEYWORD_ONLY + value: 3 + name: md + properties: + is_generator: true + scan_nd: + description: Scan over an arbitrary N-dimensional trajectory. + module: bluesky.plans + name: scan_nd + parameters: + - annotation: + type: collections.abc.Sequence[__READABLE__] + convert_device_names: true + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: detectors + - description: cycler.Cycler object mapping movable interfaces to positions + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: cycler + - default: None + description: 'hook for customizing action of inner loop (messages per step). + + See docstring of :func:`bluesky.plan_stubs.one_nd_step` (the default) + + for details.' + kind: + name: KEYWORD_ONLY + value: 3 + name: per_step + - annotation: + type: typing.Optional[dict[str, typing.Any]] + default: None + description: metadata + kind: + name: KEYWORD_ONLY + value: 3 + name: md + properties: + is_generator: true + sim_multirun_plan_nested: + description: 'Simulated multi-run plan: two nested runs. The plan is included + for testing purposes only.' + module: __main__ + name: sim_multirun_plan_nested + parameters: + - annotation: + type: int + description: The number of measurements in the outer run. Inner run will contain + 'npts+1' measurements. + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: npts + - annotation: + type: float + default: '1.0' + description: Delay between measurements. + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: delay + properties: + is_generator: true + spiral: + description: Spiral scan, centered around (x_start, y_start) + module: bluesky.plans + name: spiral + parameters: + - annotation: + type: collections.abc.Sequence[__READABLE__] + convert_device_names: true + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: detectors + - annotation: + type: __MOVABLE__ + convert_device_names: true + description: any 'settable' object (motor, temp controller, etc.) + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: x_motor + - annotation: + type: __MOVABLE__ + convert_device_names: true + description: any 'settable' object (motor, temp controller, etc.) + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: y_motor + - annotation: + type: float + description: x center + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: x_start + - annotation: + type: float + description: y center + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: y_start + - annotation: + type: float + description: x width of spiral + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: x_range + - annotation: + type: float + description: y width of spiral + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: y_range + - annotation: + type: float + description: Delta radius along the minor axis of the ellipse. + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: dr + - annotation: + type: float + description: Number of theta steps + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: nth + - annotation: + type: typing.Optional[float] + default: None + description: 'Delta radius along the major axis of the ellipse. If None, defaults + to + + dr.' + kind: + name: KEYWORD_ONLY + value: 3 + name: dr_y + - annotation: + type: typing.Optional[float] + default: '0.0' + description: Tilt angle in radians, default 0.0 + kind: + name: KEYWORD_ONLY + value: 3 + name: tilt + - default: None + description: 'hook for customizing action of inner loop (messages per step). + + See docstring of :func:`bluesky.plan_stubs.one_nd_step` (the default) + + for details.' + kind: + name: KEYWORD_ONLY + value: 3 + name: per_step + - annotation: + type: typing.Optional[dict[str, typing.Any]] + default: None + description: metadata + kind: + name: KEYWORD_ONLY + value: 3 + name: md + properties: + is_generator: true + spiral_fermat: + description: Absolute fermat spiral scan, centered around (x_start, y_start) + module: bluesky.plans + name: spiral_fermat + parameters: + - annotation: + type: collections.abc.Sequence[__READABLE__] + convert_device_names: true + description: list of 'readable' objects + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: detectors + - annotation: + type: __MOVABLE__ + convert_device_names: true + description: any 'settable' object (motor, temp controller, etc.) + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: x_motor + - annotation: + type: __MOVABLE__ + convert_device_names: true + description: any 'settable' object (motor, temp controller, etc.) + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: y_motor + - annotation: + type: float + description: x center + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: x_start + - annotation: + type: float + description: y center + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: y_start + - annotation: + type: float + description: x width of spiral + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: x_range + - annotation: + type: float + description: y width of spiral + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: y_range + - annotation: + type: float + description: delta radius + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: dr + - annotation: + type: float + description: radius gets divided by this + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: factor + - annotation: + type: typing.Optional[float] + default: None + description: 'Delta radius along the major axis of the ellipse, if not specifed + + defaults to dr.' + kind: + name: KEYWORD_ONLY + value: 3 + name: dr_y + - annotation: + type: typing.Optional[float] + default: '0.0' + description: Tilt angle in radians, default 0.0 + kind: + name: KEYWORD_ONLY + value: 3 + name: tilt + - default: None + description: 'hook for customizing action of inner loop (messages per step). + + See docstring of :func:`bluesky.plan_stubs.one_nd_step` (the default) + + for details.' + kind: + name: KEYWORD_ONLY + value: 3 + name: per_step + - annotation: + type: typing.Optional[dict[str, typing.Any]] + default: None + description: metadata + kind: + name: KEYWORD_ONLY + value: 3 + name: md + properties: + is_generator: true + spiral_square: + description: Absolute square spiral scan, centered around (x_center, y_center) + module: bluesky.plans + name: spiral_square + parameters: + - annotation: + type: collections.abc.Sequence[__READABLE__] + convert_device_names: true + description: list of 'readable' objects + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: detectors + - annotation: + type: __MOVABLE__ + convert_device_names: true + description: any 'settable' object (motor, temp controller, etc.) + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: x_motor + - annotation: + type: __MOVABLE__ + convert_device_names: true + description: any 'settable' object (motor, temp controller, etc.) + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: y_motor + - annotation: + type: float + description: x center + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: x_center + - annotation: + type: float + description: y center + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: y_center + - annotation: + type: float + description: x width of spiral + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: x_range + - annotation: + type: float + description: y width of spiral + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: y_range + - annotation: + type: float + description: number of x axis points + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: x_num + - annotation: + type: float + description: Number of y axis points. + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: y_num + - default: None + description: 'hook for cutomizing action of inner loop (messages per step). + + See docstring of :func:`bluesky.plans.one_nd_step` (the default) for + + details.' + kind: + name: KEYWORD_ONLY + value: 3 + name: per_step + - annotation: + type: typing.Optional[dict[str, typing.Any]] + default: None + description: metadata + kind: + name: KEYWORD_ONLY + value: 3 + name: md + properties: + is_generator: true + tune_centroid: + description: 'plan: tune a motor to the centroid of signal(motor)' + module: bluesky.plans + name: tune_centroid + parameters: + - annotation: + type: collections.abc.Sequence[__READABLE__] + convert_device_names: true + description: list of 'readable' objects + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: detectors + - annotation: + type: str + description: detector field whose output is to maximize + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: signal + - annotation: + type: __MOVABLE__ + convert_device_names: true + description: any 'settable' object (motor, temp controller, etc.) + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: motor + - annotation: + type: float + description: start of range + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: start + - annotation: + type: float + description: 'end of range, note: start < stop' + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: stop + - annotation: + type: float + description: smallest step size to use. + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: min_step + - annotation: + type: int + default: '10' + description: number of points with each traversal, default = 10 + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: num + - annotation: + type: float + default: '3.0' + description: 'used in calculating new range after each pass + + + note: step_factor > 1.0, default = 3' + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: step_factor + - annotation: + type: bool + default: 'False' + description: if False (default), always scan from start to stop + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: snake + - annotation: + type: typing.Optional[dict[str, typing.Any]] + default: None + description: metadata + kind: + name: KEYWORD_ONLY + value: 3 + name: md + properties: + is_generator: true + tweak: + description: Move and motor and read a detector with an interactive prompt. + module: bluesky.plans + name: tweak + parameters: + - annotation: + type: __READABLE__ + convert_device_names: true + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: detector + - annotation: + type: str + description: data field whose output is the focus of the adaptive tuning + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: target_field + - annotation: + type: __MOVABLE__ + convert_device_names: true + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: motor + - annotation: + type: float + description: initial suggestion for step size + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: step + - annotation: + type: typing.Optional[dict[str, typing.Any]] + default: None + description: metadata + kind: + name: KEYWORD_ONLY + value: 3 + name: md + properties: + is_generator: true + x2x_scan: + description: Relatively scan over two motors in a 2:1 ratio + module: bluesky.plans + name: x2x_scan + parameters: + - annotation: + type: collections.abc.Sequence[__READABLE__] + convert_device_names: true + description: list of 'readable' objects + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: detectors + - annotation: + type: __MOVABLE__ + convert_device_names: true + description: The second motor will move half as much as the first + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: motor1 + - annotation: + type: __MOVABLE__ + convert_device_names: true + description: The second motor will move half as much as the first + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: motor2 + - annotation: + type: float + description: 'The relative limits of the first motor. The second motor + + will move between ``start / 2`` and ``stop / 2``' + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: start + - annotation: + type: float + description: 'The relative limits of the first motor. The second motor + + will move between ``start / 2`` and ``stop / 2``' + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: stop + - annotation: + type: int + description: number of steps in the scan + kind: + name: POSITIONAL_OR_KEYWORD + value: 1 + name: num + - default: None + description: 'hook for cutomizing action of inner loop (messages per step). + + See docstring of :func:`bluesky.plan_stubs.one_nd_step` (the default) + + for details.' + kind: + name: KEYWORD_ONLY + value: 3 + name: per_step + - annotation: + type: typing.Optional[dict[str, typing.Any]] + default: None + description: metadata + kind: + name: KEYWORD_ONLY + value: 3 + name: md + properties: + is_generator: true diff --git a/services/bluesky-services/ipython-profile/profile_collection_sim/startup/user_group_permissions.yaml b/services/bluesky-services/ipython-profile/profile_collection_sim/startup/user_group_permissions.yaml new file mode 100644 index 0000000000..6678478cb4 --- /dev/null +++ b/services/bluesky-services/ipython-profile/profile_collection_sim/startup/user_group_permissions.yaml @@ -0,0 +1,48 @@ +user_groups: + root: # Defines the rules for preliminary filtering of plan/device/function names for all groups. + allowed_plans: + - null # Allow all + forbidden_plans: + - ":^_" # All plans with names starting with '_' + allowed_devices: + - null # Allow all + forbidden_devices: + - ":^_:?.*" # All devices with names starting with '_' + allowed_functions: + - null # Allow all + forbidden_functions: + - ":^_" # All functions with names starting with '_' + primary: # Default group. The group can be renamed or other groups may be created. + allowed_plans: + - ":.*" # Different way to allow all plans. + forbidden_plans: + - null # Nothing is forbidden + allowed_devices: + - ":?.*:depth=5" # Allow all device and subdevices. Maximum deepth for subdevices is 5. + forbidden_devices: + - null # Nothing is forbidden + allowed_functions: + - "function_sleep" # Explicitly listed name + - ":^func_for_test" + test_user: # Another group used for unit tests. + allowed_plans: + - ":^count" # Use regular expression patterns + - ":scan$" + forbidden_plans: + - ":^adaptive_scan$" # Use regular expression patterns + - ":^inner_product" + allowed_devices: + - ":^det:?.*" # Use regular expression patterns + - ":^motor:?.*" + - ":^sim_bundle_A:?.*" + forbidden_devices: + - ":^det[3-5]$:?.*" # Use regular expression patterns + - ":^motor\\d+$:?.*" + allowed_functions: + - ":element$" + - ":elements$" + - "function_sleep" + - "clear_buffer" + - ":^unit_test.*$" + forbidden_functions: + - ":^_" # All functions with names starting with '_' From f5bebacb110d51bfd3cdc4f449cddfee7f6c7eb0 Mon Sep 17 00:00:00 2001 From: JMit-dev Date: Wed, 30 Jul 2025 12:53:16 -0400 Subject: [PATCH 2/2] fix: zmq console publish env variable --- services/bluesky-services/Dockerfile.queue-server | 6 +++--- services/bluesky-services/docker-compose.yml | 2 ++ 2 files changed, 5 insertions(+), 3 deletions(-) diff --git a/services/bluesky-services/Dockerfile.queue-server b/services/bluesky-services/Dockerfile.queue-server index 6cdbb12172..e8afaca9aa 100644 --- a/services/bluesky-services/Dockerfile.queue-server +++ b/services/bluesky-services/Dockerfile.queue-server @@ -22,7 +22,7 @@ WORKDIR /app # Copy IPython profile from local directory COPY ipython-profile/ /root/.ipython/ -# Expose port for 0MQ communication -EXPOSE 60615 +# Expose ports for 0MQ communication +EXPOSE 60615 60625 -CMD ["sh", "-c", "start-re-manager --use-ipython-kernel=ON --zmq-publish-console=ON --startup-profile collection_sim --redis-addr=${REDIS_HOST:-redis}:${REDIS_PORT:-6379}"] \ No newline at end of file +CMD ["sh", "-c", "start-re-manager --use-ipython-kernel=ON --zmq-publish-console=ON --startup-profile collection_sim --redis-addr=${REDIS_HOST:-redis}:${REDIS_PORT:-6379} --zmq-info-addr=tcp://*:60625"] \ No newline at end of file diff --git a/services/bluesky-services/docker-compose.yml b/services/bluesky-services/docker-compose.yml index 6a9bd48b93..ae92b1d255 100644 --- a/services/bluesky-services/docker-compose.yml +++ b/services/bluesky-services/docker-compose.yml @@ -25,6 +25,7 @@ services: container_name: bluesky-queue-server ports: - "60615:60615" + - "60625:60625" environment: - REDIS_HOST=redis - REDIS_PORT=6379 @@ -50,6 +51,7 @@ services: environment: - QSERVER_HTTP_SERVER_SINGLE_USER_API_KEY=a - QSERVER_ZMQ_CONTROL_ADDRESS=tcp://queue-server:60615 + - QSERVER_ZMQ_INFO_ADDRESS=tcp://queue-server:60625 depends_on: queue-server: condition: service_healthy