Events Module

The events subsystem provides a real-time stream of Seestar state changes over a persistent TCP connection. Use start_listener() to begin collecting events in a background thread, and inspect LATEST_STATE for the most recent data.

Listener

seestarpy.events.event_listener.dashboard_url()

Get file paths to the bundled HTML dashboard pages.

These dashboards connect to the WebSocket server started by start_listener() and display live Seestar state. Open the returned paths in a web browser.

Returns:

Paths to the basic.html and fancy.html dashboard files.

Return type:

list of pathlib.Path

Examples

>>> from seestarpy.events.event_listener import dashboard_url
>>> dashboard_url()
[PosixPath('.../dashboards/basic.html'), PosixPath('.../dashboards/fancy.html')]
async seestarpy.events.event_listener.heartbeat(writer)

Send periodic heartbeat messages to keep the TCP connection alive.

Cycles through several query methods (get_device_state, iscope_get_app_state, scope_get_equ_coord, scope_get_horiz_coord) so that event_stream.LATEST_STATE stays up to date even when the Seestar is idle.

Parameters:

writer (asyncio.StreamWriter) – The open TCP writer for the Seestar connection.

async seestarpy.events.event_listener.run()

Main event loop: connect to the Seestar and process incoming events.

Opens a persistent TCP connection, starts a heartbeat() task, and reads newline-delimited JSON messages. Each message is passed to event_stream.handle_event(). Automatically reconnects on connection loss.

seestarpy.events.event_listener.start_listener(with_websocket=True)

Start the background event listener in a daemon thread.

Opens a persistent TCP connection to the Seestar and continuously reads incoming event messages, keeping event_stream.LATEST_STATE up to date. Optionally starts a WebSocket server so that the bundled HTML dashboards can display live data.

This function is safe to call multiple times — subsequent calls are a no-op if the listener is already running.

Parameters:

with_websocket (bool, optional) – Also start the WebSocket relay server on ws://0.0.0.0:8765. Default is True.

See also

stop_listener

Stop the background listener.

dashboard_url

Get paths to the bundled HTML dashboards.

Examples

>>> from seestarpy import start_listener, stop_listener
>>> start_listener()
[seestarpy] Starting background thread with asyncio loop.
Connecting to 192.168.1.243:4700...
Connected to 192.168.1.243:4700
>>> stop_listener()
seestarpy.events.event_listener.stop_listener()

Stop the background event listener.

Signals the listener thread to shut down and clears internal state. Safe to call even if the listener is not running.

See also

start_listener

Start the background listener.

async seestarpy.events.event_listener.websocket_server()

Start a WebSocket server that broadcasts event_stream.LATEST_STATE.

Serves on ws://0.0.0.0:8765. Each connected client receives the full state dictionary once per second. Used by the HTML dashboards returned by dashboard_url().

Event Stream

seestarpy.events.event_stream.LATEST_LOGS = deque([], maxlen=500)

Rolling buffer of the last 500 raw event dictionaries, in chronological order.

Type:

deque

seestarpy.events.event_stream.LATEST_STATE = {}

Most recent event data keyed by event type (e.g. "Stack", "PlateSolve"). Updated in real time by handle_event() while the listener is running.

Type:

dict

seestarpy.events.event_stream.handle_event(data)

Route an incoming Seestar event into the shared state stores.

Extracts the "Event" key from data and upserts the entry in LATEST_STATE, so that each event type always holds the most recent message. The full message is also appended to LATEST_LOGS.

Parameters:

data (dict) – A JSON-parsed Seestar message that must contain an "Event" key to be stored. Messages without an "Event" key are silently ignored.

Event Definitions

Typed dataclasses for every known Seestar event. Each class maps 1-to-1 with the "Event" key in the JSON messages sent by the device.

class seestarpy.events.event_definitions.AIProcess(state, lapse_ms, ori_name=None, dst_name=None, route=<factory>)

Bases: object

AI image-processing event.

Emitted when the Seestar applies its on-board AI enhancement to an image (e.g. noise reduction, sharpening).

Parameters:

  • state (str) – Current state. Values: ‘working’, ‘complete’

  • lapse_ms (int) – Elapsed time in ms.

  • ori_name (str) – Original image filename. Example: ‘ori_path.jpg’

  • dst_name (str) – Destination image filename. Example: ‘dst_path.jpg’

  • route (list) – Contextual route. Example: [‘View’]

dst_name: str | None = None
lapse_ms: int
ori_name: str | None = None
route: List[str] | None
state: str
class seestarpy.events.event_definitions.Alert(error, code)

Bases: object

Alert event raised during observations.

Emitted when the Seestar encounters a problem such as the target dropping below the horizon, too few stars for stacking, or star trails being detected.

Parameters:

  • error (str) – Description of the error. Values: ‘below horizon’, ‘stack error, too few stars’, ‘stack error, transform failed’, ‘star trails’

  • code (int) – Numeric error code. Values: 263, 264, 270, 530

code: int
error: str
class seestarpy.events.event_definitions.Annotate(state, page=None, lapse_ms=None, result=<factory>, route=<factory>)

Bases: object

Image-annotation event.

Emitted when the Seestar annotates a stacked image with detected object labels (stars, DSOs, etc.).

Parameters:

  • state (str) – Status of the annotation. Values: ‘start’, ‘working’, ‘complete’

  • page (str) – Page context. Values: ‘stack’

  • lapse_ms (int) – Time taken for annotation.

  • result (dict) – Annotation results including object metadata.

  • route (list) – UI route. Example: [‘View’, ‘Stack’]

lapse_ms: int | None = None
page: str | None = None
result: Dict[str, Any] | None
route: List[str] | None
state: str
class seestarpy.events.event_definitions.AutoFocus(state, lapse_ms=None, error=None, code=None, route=<factory>, result=<factory>)

Bases: object

Auto-focus event.

Emitted during the automated focus routine. The Seestar sweeps through focuser positions and measures star FWHM to find the optimal focus point.

Parameters:

  • state (str) – Autofocus state. Values: ‘start’, ‘working’, ‘fail’

  • lapse_ms (int) – Elapsed time in milliseconds.

  • error (str) – Description of error if failed. Values: ‘no star is detected’

  • code (int) – Numeric error code. Values: 279

  • route (list) – Route context. Example: [‘View’]

  • result (dict) – Result of focus scan (scale, points, etc).

code: int | None = None
error: str | None = None
lapse_ms: int | None = None
result: Dict[str, Any] | None
route: List[str] | None
state: str
class seestarpy.events.event_definitions.AutoGoto(state, page=None, tag=None, func=None, error=None, code=None, target_ra_dec=<factory>, target_name=None, lapse_ms=None, count=None, hint=None, route=<factory>)

Bases: object

Auto-goto event.

Emitted during the automated goto sequence: the mount slews to the target coordinates, then enters a plate-solve loop to refine pointing accuracy.

Parameters:

  • state (str) – State of the goto process. Values: ‘start’, ‘working’, ‘complete’, ‘fail’

  • page (str) – UI page. Values: ‘preview’

  • tag (str) – UI tag. Values: ‘Exposure’

  • func (str) – Function executed. Values: ‘goto_ra_dec’

  • error (str) – Error reason. Values: ‘mount goto failed’, ‘solve failed’

  • code (int) – Error code. Values: 251, 501

  • target_ra_dec (list) – Target coordinates in RA/DEC. Example: [13.4, 54.900002]

  • target_name (str) – Name of the target. Example: ‘Mizar’

  • lapse_ms (int) – Elapsed time in milliseconds.

  • count (int) – Retry or step count.

  • hint (bool) – Whether a hint was used. Values: True, False

  • route (list) – UI route. Examples: [‘View’], [‘View’, ‘3PPA’]

code: int | None = None
count: int | None = None
error: str | None = None
func: str | None = None
hint: bool | None = None
lapse_ms: int | None = None
page: str | None = None
route: List[str] | None
state: str
tag: str | None = None
target_name: str | None = None
target_ra_dec: List[float] | None
class seestarpy.events.event_definitions.AutoGotoStep(state, page=None, tag=None, func=None, count=None, error=None, code=None)

Bases: object

Individual step within an AutoGoto sequence.

Emitted for each slew-and-solve iteration during the goto process.

Parameters:

  • state (str) – Status of the step. Values: ‘fail’

  • page (str) – UI page. Values: ‘preview’

  • tag (str) – UI tag. Values: ‘Exposure’

  • func (str) – Function name. Values: ‘goto_ra_dec’

  • count (int) – Step or retry count. Example: 6

  • error (str) – Error reason. Values: ‘mount goto failed’

  • code (int) – Error code. Values: 501

code: int | None = None
count: int | None = None
error: str | None = None
func: str | None = None
page: str | None = None
state: str
tag: str | None = None
class seestarpy.events.event_definitions.BalanceSensor(code, data=<factory>)

Bases: object

Balance-sensor reading event.

Reports the accelerometer data (x, y, z) and the computed tilt angle of the Seestar’s body. Useful for verifying the tripod is level.

Parameters:

  • code (int) – Status code. Values: 0

  • data (dict) – Balance data with x, y, z acceleration and angle. Example: {‘x’: 0.316085, ‘y’: -0.515709, ‘z’: 1.104264, ‘angle’: 28.712015}

code: int
data: Dict[str, Any] | None
class seestarpy.events.event_definitions.ContinuousExposure(state, lapse_ms=None, fps=None, route=<factory>)

Bases: object

Continuous-exposure (live-view) event.

Emitted while the camera is running in live-view mode, before stacking has started. Reports the frame rate and elapsed time.

Parameters:

  • state (str) – Current state. Values: ‘cancel’, ‘working’

  • lapse_ms (int) – Duration in milliseconds.

  • fps (float) – Frames per second. Example: 2.024457

  • route (list) – Route in the UI. Example: [‘View’]

fps: float | None = None
lapse_ms: int | None = None
route: List[str] | None
state: str
class seestarpy.events.event_definitions.DarkLibrary(state, lapse_ms=None, percent=None, route=<factory>)

Bases: object

Dark-frame library creation event.

Emitted while the Seestar is capturing dark frames for calibration. Reports progress as a percentage.

Parameters:

  • state (str) – Process state. Values: ‘working’, ‘complete’

  • lapse_ms (int) – Time in milliseconds.

  • percent (float) – Completion percentage. Example: 100.0

  • route (list) – UI route. Example: [‘View’, ‘Initialise’]

lapse_ms: int | None = None
percent: float | None = None
route: List[str] | None
state: str
class seestarpy.events.event_definitions.DiskSpace(used_percent)

Bases: object

Disk-space usage event.

Reports the percentage of used storage on the Seestar’s internal eMMC drive.

Parameters:

used_percent (int) – Used space percentage. Example: 38

used_percent: int
class seestarpy.events.event_definitions.Exposure(state, page=None, tag=None, ac_count=None, exp_us=None, gain=None, error=None, code=None, lapse_ms=None, exp_ms=None, route=<factory>)

Bases: object

Single-exposure capture event.

Emitted for each individual sub-frame during stacking or auto-goto plate-solving. Reports the exposure duration, gain, and capture state.

Parameters:

  • state (str) – Current state of the exposure. Values: ‘start’, ‘working’, ‘downloading’, ‘complete’, ‘fail’, ‘cancel’

  • page (str) – UI context. Values: ‘preview’, ‘stack’

  • tag (str) – Tag for identifying exposure type. Example: ‘Exposure-AutoGoto’

  • ac_count (int) – Auto capture count. Example: 1

  • exp_us (int) – Exposure time in microseconds. Example: 2000000, 10000000

  • gain (int) – Gain setting. Example: 80

  • error (str) – Error description. Values: ‘interrupt’

  • code (int) – Error code. Values: 514

  • lapse_ms (int) – Elapsed time in milliseconds.

  • exp_ms (float) – Exposure duration in milliseconds. Example: 1000.0, 2000.0, 10000.0

  • route (list) – Route path. Examples: [‘View’, ‘Stack’], [‘View’, ‘AutoFocus’]

ac_count: int | None = None
code: int | None = None
error: str | None = None
exp_ms: float | None = None
exp_us: int | None = None
gain: int | None = None
lapse_ms: int | None = None
page: str | None = None
route: List[str] | None
state: str
tag: str | None = None
class seestarpy.events.event_definitions.FocuserMove(state, lapse_ms=None, position=None, route=<factory>)

Bases: object

Focuser-movement event.

Emitted when the focuser motor moves to a new position, either manually or as part of the auto-focus routine.

Parameters:

  • state (str) – State of the focuser. Values: ‘complete’, ‘working’

  • lapse_ms (int) – Time in milliseconds.

  • position (int) – Final position. Examples: 0, 1540, 1580, 1820

  • route (list) – UI route. Examples: [‘View’, ‘AutoFocus’]

lapse_ms: int | None = None
position: int | None = None
route: List[str] | None
state: str
class seestarpy.events.event_definitions.GSensorMove(Timestamp)

Bases: object

G-sensor movement-detection event.

Emitted when the accelerometer detects that the Seestar has been physically moved or bumped.

Parameters:

Timestamp (str) – Time the movement was registered. Example: ‘2205.182986165’

Timestamp: str
class seestarpy.events.event_definitions.Initialise(Timestamp, state, lapse_ms=None, route=<factory>)

Bases: object

Device-initialisation event.

Emitted during the Seestar’s startup sequence (dark-frame loading, sensor calibration, etc.).

Parameters:

  • Timestamp (str) – Time the init occurred. Example: ‘718.139747786’

  • state (str) – Status of initialization. Values: ‘working’, ‘complete’

  • lapse_ms (int) – Elapsed time.

  • route (list) – Route context. Example: [‘View’]

Timestamp: str
lapse_ms: int | None = None
route: List[str] | None
state: str
class seestarpy.events.event_definitions.MountMode(Timestamp, equ_mode)

Bases: object

Mount-mode change event.

Emitted when the mount switches between equatorial (EQ) and altitude-azimuth (AzAlt) mode.

Parameters:

  • Timestamp (str) – Event timestamp. Example: ‘1902.412544972’

  • equ_mode (bool) – Whether equatorial mode is enabled. Values: True, False

Timestamp: str
equ_mode: bool
class seestarpy.events.event_definitions.MoveByAngle(state, value=None)

Bases: object

Move-by-angle event.

Emitted when the mount is commanded to move by a specific angular offset (e.g. during polar-alignment adjustments).

Parameters:

  • state (str) – State of the movement. Values: ‘start’, ‘moving’, ‘complete’

  • value (float) – Angle in degrees. Example: 10.043414

state: str
value: float | None = None
class seestarpy.events.event_definitions.PiStatus(temp=None, battery_temp=None, battery_capacity=None, charger_status=None)

Bases: object

Raspberry Pi hardware status event.

Periodic report of the Seestar’s internal processor temperature, battery level, and charging state.

Parameters:

  • temp (float) – Temperature in Celsius. Example: 46.5

  • battery_temp (int) – Battery temperature. Example: 27

  • battery_capacity (int) – Battery percentage. Example: 42

  • charger_status (str) – Charging state. Values: ‘Discharging’

battery_capacity: int | None = None
battery_temp: int | None = None
charger_status: str | None = None
temp: float | None = None
class seestarpy.events.event_definitions.PlateSolve(state, page=None, tag=None, ac_count=None, error=None, code=None, lapse_ms=None, star_number=None, ra_dec=<factory>, fov=<factory>, focal_len=None, angle=None, image_id=None, result=<factory>, route=<factory>)

Bases: object

Plate-solve event.

Emitted during astrometric plate-solving of captured frames. Reports the solved RA/Dec position, field of view, rotation angle, and number of detected stars.

Parameters:

  • state (str) – Current solving state. Values: ‘start’, ‘solving’, ‘working’, ‘complete’, ‘fail’

  • page (str) – Context page. Values: ‘preview’, ‘stack’

  • tag (str) – Exposure tag. Example: ‘Exposure-AutoGoto’

  • ac_count (int) – Auto capture count. Example: 1

  • error (str) – Error message. Values: ‘solve failed’

  • code (int) – Error code. Values: 251

  • lapse_ms (int) – Time elapsed in ms. Example: 3169, 30964

  • star_number (int) – Number of stars detected. Examples: 2148, 429, 6802

  • ra_dec (list) – Right Ascension and Declination. Example: [14.328956, 19.398779]

  • fov (list) – Field of view in degrees. Example: [0.711682, 1.265403]

  • focal_len (float) – Focal length in mm. Example: 252.111633

  • angle (float) – Rotation angle in degrees. Example: 308.333008

  • image_id (int) – Image identifier. Example: 852

  • result (dict) – Plate solve result details.

  • route (list) – Route in UI. Examples: [‘View’, ‘AutoGoto’]

ac_count: int | None = None
angle: float | None = None
code: int | None = None
error: str | None = None
focal_len: float | None = None
fov: List[float] | None
image_id: int | None = None
lapse_ms: int | None = None
page: str | None = None
ra_dec: List[float] | None
result: Dict[str, Any] | None
route: List[str] | None
star_number: int | None = None
state: str
tag: str | None = None
class seestarpy.events.event_definitions.SaveImage(state, filename=None, fullname=None)

Bases: object

Image-save event.

Emitted when a stacked or sub-frame image is saved to the Seestar’s internal eMMC storage.

Parameters:

  • state (str) – Save state. Values: ‘complete’

  • filename (str) – File name only. Example: ‘Stacked_36_Polaris_10.0s_IRCUT_20250720-224643.fit’

  • fullname (str) – Full path name. Example: ‘MyWorks/Polaris/Stacked_36_Polaris_10.0s_IRCUT_20250720-224643.fit’

filename: str | None = None
fullname: str | None = None
state: str
class seestarpy.events.event_definitions.ScopeGoto(state, lapse_ms=None, cur_ra_dec=<factory>, dist_deg=None, error=None, code=None, route=<factory>)

Bases: object

Scope-goto (low-level slew) event.

Emitted as the mount physically moves toward the target coordinates. Reports the current position and remaining angular distance.

Parameters:

  • state (str) – Movement state. Values: ‘complete’, ‘fail’, ‘working’

  • lapse_ms (int) – Time taken for goto in ms.

  • cur_ra_dec (list) – Current RA/DEC position. Example: [13.399722, 54.9]

  • dist_deg (float) – Distance in degrees to target. Example: 0.002394, 123.233118

  • error (str) – Error message. Values: ‘mount goto failed’

  • code (int) – Error code. Values: 501

  • route (list) – UI path. Example: [‘View’, ‘AutoGoto’]

code: int | None = None
cur_ra_dec: List[float] | None
dist_deg: float | None = None
error: str | None = None
lapse_ms: int | None = None
route: List[str] | None
state: str
class seestarpy.events.event_definitions.ScopeHome(state, lapse_ms=None, close=None, equ_mode=None)

Bases: object

Scope-home (park) event.

Emitted when the Seestar arm moves to the parked (closed) position.

Parameters:

  • state (str) – State of homing. Values: ‘complete’, ‘working’

  • lapse_ms (int) – Time taken for the homing process in ms.

  • close (bool) – Whether the process was a close action. Values: True, False

  • equ_mode (bool) – Equatorial mode state. Values: True, False

close: bool | None = None
equ_mode: bool | None = None
lapse_ms: int | None = None
state: str
class seestarpy.events.event_definitions.ScopeMoveToHorizon(state, lapse_ms=None, close=None)

Bases: object

Scope move-to-horizon event.

Emitted when the Seestar arm moves from the parked position to the horizontal (open) position, ready for observing.

Parameters:

  • state (str) – Status of movement. Values: ‘complete’, ‘working’

  • lapse_ms (int) – Time in milliseconds.

  • close (bool) – Whether to close after movement. Values: True, False

close: bool | None = None
lapse_ms: int | None = None
state: str
class seestarpy.events.event_definitions.ScopeTrack(state, tracking=None, manual=None, error=None, code=None, route=<factory>)

Bases: object

Sidereal-tracking state event.

Emitted when tracking is toggled on or off, or when a tracking error occurs (e.g. target below horizon, mount sync failure).

Parameters:

  • state (str) – Tracking status. Values: ‘on’, ‘off’

  • tracking (bool) – Whether tracking is active. Values: True, False

  • manual (bool) – Manual tracking toggle. Values: True, False

  • error (str) – Error message. Values: ‘below horizon’, ‘equipment is moving’, ‘fail to operate’, ‘mount sync failed’

  • code (int) – Error code. Values: 203, 207, 270, 502

  • route (list) – Route path. Example: []

code: int | None = None
error: str | None = None
manual: bool | None = None
route: List[str] | None
state: str
tracking: bool | None = None
class seestarpy.events.event_definitions.Stack(state, lapse_ms=None, frame_errcode=None, stacked_frame=None, dropped_frame=None, total_frame=None, frame_type=None, error=None, code=None, can_annotate=None, jpg_name=None, route=<factory>)

Bases: object

Image-stacking event.

Emitted for each stacking cycle. Reports the number of stacked and dropped frames, frame error codes, and whether annotation is available on the current stack.

Parameters:

  • state (str) – State of the stacking. Values: ‘start’, ‘working’, ‘cancel’, ‘frame_complete’

  • lapse_ms (int) – Time elapsed in milliseconds.

  • frame_errcode (int) – Frame error code. Values: -1, 0, 263, 530

  • stacked_frame (int) – Number of frames stacked.

  • dropped_frame (int) – Number of dropped frames.

  • total_frame (int) – Total frames received.

  • frame_type (str) – Type of frame. Example: ‘light’

  • error (str) – Error message. Examples: ‘stack error, too few stars’, ‘star trails’, ‘no error’

  • code (int) – Error code. Examples: 0, 263, 530

  • can_annotate (bool) – Whether annotation is available. Values: True, False

  • jpg_name (str) – JPEG output filename.

  • route (list) – Route in UI. Example: [‘View’]

can_annotate: bool | None = None
code: int | None = None
dropped_frame: int | None = None
error: str | None = None
frame_errcode: int | None = None
frame_type: str | None = None
jpg_name: str | None = None
lapse_ms: int | None = None
route: List[str] | None
stacked_frame: int | None = None
state: str
total_frame: int | None = None
class seestarpy.events.event_definitions.ThreePPA(state, lapse_ms, percent=None, calib_fail_autogoto=None, offset=<factory>, equ_offset=<factory>, route=<factory>, state_code=None, auto_move=None, auto_update=None, paused=None, detail=<factory>, retry_cnt=None)

Bases: object

Three-Point Polar Alignment (3PPA) event.

Emitted during the automated polar-alignment sequence. The Seestar slews to three sky positions, plate-solves each one, and computes the azimuth/altitude offset required to align the mount’s polar axis.

Parameters:

  • state (str) – State of the process. Values: ‘start’, ‘working’, ‘complete’, ‘delay1’, ‘delay2’, ‘move1’, ‘move2’

  • lapse_ms (int) – Elapsed time in milliseconds.

  • percent (float) – Progress percentage. Values: 0.0 to 100.0

  • calib_fail_autogoto (bool) – Whether calibration failed to auto-goto. Values: True, False

  • offset (list) – Az-Alt offset [x, y] in degrees. Example: [-0.986416, -0.450118]

  • equ_offset (list) – Equatorial offset [RA, DEC] in degrees. Example: [-56.145756, 136.862207]

  • route (list) – Route stack. Example: [‘View’]

  • state_code (int) – Internal state code. Values: 1, 5, 6, 10, 11

  • auto_move (bool) – Whether auto movement is enabled. Values: True, False

  • auto_update (bool) – Whether auto update is enabled. Values: True, False

  • paused (bool) – Whether the process is paused. Values: True, False

  • detail (dict) – Additional detail such as total_ms, lapse_ms

  • retry_cnt (int) – Retry count. Values: 0, 1, …

auto_move: bool | None = None
auto_update: bool | None = None
calib_fail_autogoto: bool | None = None
detail: Dict[str, Any] | None
equ_offset: List[float] | None
lapse_ms: int
offset: List[float] | None
paused: bool | None = None
percent: float | None = None
retry_cnt: int | None = None
route: List[str] | None
state: str
state_code: int | None = None
class seestarpy.events.event_definitions.View(state, lapse_ms=None, mode=None, cam_id=None, target_ra_dec=<factory>, target_name=None, lp_filter=None, gain=None, route=<factory>)

Bases: object

Top-level view-session event.

Emitted when a viewing session starts, changes mode, or completes. Carries the target name, coordinates, gain, and filter state.

Parameters:

  • state (str) – View state. Values: ‘cancel’, ‘working’

  • lapse_ms (int) – Elapsed time.

  • mode (str) – View mode. Example: ‘star’

  • cam_id (int) – Camera ID. Example: 0

  • target_ra_dec (list) – Target RA/DEC coordinates. Example: [13.4, 54.900002]

  • target_name (str) – Target name. Example: ‘Mizar’

  • lp_filter (bool) – Whether LP filter is applied. Values: True, False

  • gain (int) – Gain level. Example: 80

  • route (list) – Route context. Example: []

cam_id: int | None = None
gain: int | None = None
lapse_ms: int | None = None
lp_filter: bool | None = None
mode: str | None = None
route: List[str] | None
state: str
target_name: str | None = None
target_ra_dec: List[float] | None
class seestarpy.events.event_definitions.WheelMove(state, position=None)

Bases: object

Filter-wheel movement event.

Emitted when the filter wheel rotates to a new position (e.g. switching between IR-cut and narrow-band filters).

Parameters:

  • state (str) – Movement state. Values: ‘start’, ‘complete’

  • position (int) – Position index. Examples: 0, 1

position: int | None = None
state: str

Event Watcher (experimental)