raphael
a2ebbf7c65
Python client:
- eq.names.event.* / .alarm.* / .command.* / .var.* / .constant.* —
autocomplete-able, typo-safe name lookup backed by the Describe RPC
(lazy, cached; AttributeError on bad name with close-match hints)
- @eq.command decorator — binds a handler by function name, validated
against the equipment's real command set at decoration time
- eq.report_substrate() — E90 wafer milestone reporting
- eq.report_module() — E157 module state reporting (auto-create)
Daemon (C++ service):
- ReportSubstrate RPC — drives E90 location + processing FSMs
- ReportModule RPC — drives E157 module FSM (auto-create on first report)
- ack_from_outcome() helper — consistent Ack mapping for read_sync results
Proto: SubstrateReport, ModuleReport, EquipmentDescription,
SpoolFlushRequest, TerminalMessage; Describe, FlushSpool,
SendTerminalMessage RPCs
Tests: C++ FSM test (journey + ghost rejection + E157 illegal jump);
interop coverage for names API and E90/E157 round-trip
Docs: ch42 RPC table + Python example updated; ch16 daemon-path section added
Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
729 lines
33 KiB
Python
729 lines
33 KiB
Python
# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT!
|
|
"""Client and server classes corresponding to protobuf-defined services."""
|
|
import grpc
|
|
|
|
from . import equipment_pb2 as equipment__pb2
|
|
|
|
|
|
class EquipmentStub(object):
|
|
"""=============================================================================
|
|
SECS/GEM Equipment API
|
|
|
|
The daemon *is* one piece of SEMI equipment: it owns the HSMS link to the
|
|
host (MES) and speaks GEM on your behalf. Your tool software connects as a
|
|
client and only ever does two things:
|
|
|
|
• tell the equipment about itself — set variables, fire events, raise alarms
|
|
• react to what the host asks for — receive commands/jobs, answer them
|
|
|
|
Everything SECS lives inside the daemon: message framing, report definitions,
|
|
the GEM state machines, timers, spooling. You need no SEMI knowledge to use
|
|
this API. Items are addressed by the human names from your equipment config
|
|
(e.g. "chamber_pressure"), never by numeric SVID / CEID / ALID.
|
|
|
|
CAPABILITY TIERS — wire up only what your equipment is:
|
|
• Universal — variables, events, alarms, control state, commands. Every tool.
|
|
• Carriers — E87 carrier/load-port flows. Only carrier-based equipment.
|
|
• Recipes — S7 process-program transfer. Only recipe-driven equipment.
|
|
• Jobs — E40 process jobs. Only job-based process/front-end equipment.
|
|
If a tier doesn't apply, you simply never receive its HostRequest variants and
|
|
never call its report RPCs.
|
|
=============================================================================
|
|
|
|
---- Universal: report state to the host --------------------------------
|
|
"""
|
|
|
|
def __init__(self, channel):
|
|
"""Constructor.
|
|
|
|
Args:
|
|
channel: A grpc.Channel.
|
|
"""
|
|
self.SetVariables = channel.unary_unary(
|
|
'/secsgem.v1.Equipment/SetVariables',
|
|
request_serializer=equipment__pb2.VariableUpdate.SerializeToString,
|
|
response_deserializer=equipment__pb2.Ack.FromString,
|
|
)
|
|
self.GetVariables = channel.unary_unary(
|
|
'/secsgem.v1.Equipment/GetVariables',
|
|
request_serializer=equipment__pb2.VariableQuery.SerializeToString,
|
|
response_deserializer=equipment__pb2.VariableSnapshot.FromString,
|
|
)
|
|
self.FireEvent = channel.unary_unary(
|
|
'/secsgem.v1.Equipment/FireEvent',
|
|
request_serializer=equipment__pb2.Event.SerializeToString,
|
|
response_deserializer=equipment__pb2.Ack.FromString,
|
|
)
|
|
self.SetAlarm = channel.unary_unary(
|
|
'/secsgem.v1.Equipment/SetAlarm',
|
|
request_serializer=equipment__pb2.Alarm.SerializeToString,
|
|
response_deserializer=equipment__pb2.Ack.FromString,
|
|
)
|
|
self.ClearAlarm = channel.unary_unary(
|
|
'/secsgem.v1.Equipment/ClearAlarm',
|
|
request_serializer=equipment__pb2.Alarm.SerializeToString,
|
|
response_deserializer=equipment__pb2.Ack.FromString,
|
|
)
|
|
self.GetControlState = channel.unary_unary(
|
|
'/secsgem.v1.Equipment/GetControlState',
|
|
request_serializer=equipment__pb2.Empty.SerializeToString,
|
|
response_deserializer=equipment__pb2.ControlState.FromString,
|
|
)
|
|
self.RequestControlState = channel.unary_unary(
|
|
'/secsgem.v1.Equipment/RequestControlState',
|
|
request_serializer=equipment__pb2.ControlStateRequest.SerializeToString,
|
|
response_deserializer=equipment__pb2.Ack.FromString,
|
|
)
|
|
self.Subscribe = channel.unary_stream(
|
|
'/secsgem.v1.Equipment/Subscribe',
|
|
request_serializer=equipment__pb2.SubscribeRequest.SerializeToString,
|
|
response_deserializer=equipment__pb2.HostRequest.FromString,
|
|
)
|
|
self.CompleteCommand = channel.unary_unary(
|
|
'/secsgem.v1.Equipment/CompleteCommand',
|
|
request_serializer=equipment__pb2.CommandResult.SerializeToString,
|
|
response_deserializer=equipment__pb2.Ack.FromString,
|
|
)
|
|
self.ReportProcessJob = channel.unary_unary(
|
|
'/secsgem.v1.Equipment/ReportProcessJob',
|
|
request_serializer=equipment__pb2.ProcessJobState.SerializeToString,
|
|
response_deserializer=equipment__pb2.Ack.FromString,
|
|
)
|
|
self.ReportCarrier = channel.unary_unary(
|
|
'/secsgem.v1.Equipment/ReportCarrier',
|
|
request_serializer=equipment__pb2.CarrierState.SerializeToString,
|
|
response_deserializer=equipment__pb2.Ack.FromString,
|
|
)
|
|
self.ReportSubstrate = channel.unary_unary(
|
|
'/secsgem.v1.Equipment/ReportSubstrate',
|
|
request_serializer=equipment__pb2.SubstrateReport.SerializeToString,
|
|
response_deserializer=equipment__pb2.Ack.FromString,
|
|
)
|
|
self.ReportModule = channel.unary_unary(
|
|
'/secsgem.v1.Equipment/ReportModule',
|
|
request_serializer=equipment__pb2.ModuleReport.SerializeToString,
|
|
response_deserializer=equipment__pb2.Ack.FromString,
|
|
)
|
|
self.WatchHealth = channel.unary_stream(
|
|
'/secsgem.v1.Equipment/WatchHealth',
|
|
request_serializer=equipment__pb2.Empty.SerializeToString,
|
|
response_deserializer=equipment__pb2.Health.FromString,
|
|
)
|
|
self.Describe = channel.unary_unary(
|
|
'/secsgem.v1.Equipment/Describe',
|
|
request_serializer=equipment__pb2.Empty.SerializeToString,
|
|
response_deserializer=equipment__pb2.EquipmentDescription.FromString,
|
|
)
|
|
self.FlushSpool = channel.unary_unary(
|
|
'/secsgem.v1.Equipment/FlushSpool',
|
|
request_serializer=equipment__pb2.SpoolFlushRequest.SerializeToString,
|
|
response_deserializer=equipment__pb2.Ack.FromString,
|
|
)
|
|
self.SendTerminalMessage = channel.unary_unary(
|
|
'/secsgem.v1.Equipment/SendTerminalMessage',
|
|
request_serializer=equipment__pb2.TerminalMessage.SerializeToString,
|
|
response_deserializer=equipment__pb2.Ack.FromString,
|
|
)
|
|
|
|
|
|
class EquipmentServicer(object):
|
|
"""=============================================================================
|
|
SECS/GEM Equipment API
|
|
|
|
The daemon *is* one piece of SEMI equipment: it owns the HSMS link to the
|
|
host (MES) and speaks GEM on your behalf. Your tool software connects as a
|
|
client and only ever does two things:
|
|
|
|
• tell the equipment about itself — set variables, fire events, raise alarms
|
|
• react to what the host asks for — receive commands/jobs, answer them
|
|
|
|
Everything SECS lives inside the daemon: message framing, report definitions,
|
|
the GEM state machines, timers, spooling. You need no SEMI knowledge to use
|
|
this API. Items are addressed by the human names from your equipment config
|
|
(e.g. "chamber_pressure"), never by numeric SVID / CEID / ALID.
|
|
|
|
CAPABILITY TIERS — wire up only what your equipment is:
|
|
• Universal — variables, events, alarms, control state, commands. Every tool.
|
|
• Carriers — E87 carrier/load-port flows. Only carrier-based equipment.
|
|
• Recipes — S7 process-program transfer. Only recipe-driven equipment.
|
|
• Jobs — E40 process jobs. Only job-based process/front-end equipment.
|
|
If a tier doesn't apply, you simply never receive its HostRequest variants and
|
|
never call its report RPCs.
|
|
=============================================================================
|
|
|
|
---- Universal: report state to the host --------------------------------
|
|
"""
|
|
|
|
def SetVariables(self, request, context):
|
|
"""Update one or more status/data variables by name. The daemon remembers the
|
|
values, so the host always sees the latest when it polls (S1F3).
|
|
"""
|
|
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
context.set_details('Method not implemented!')
|
|
raise NotImplementedError('Method not implemented!')
|
|
|
|
def GetVariables(self, request, context):
|
|
"""Read back what the daemon currently holds (useful on tool restart/reconnect).
|
|
"""
|
|
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
context.set_details('Method not implemented!')
|
|
raise NotImplementedError('Method not implemented!')
|
|
|
|
def FireEvent(self, request, context):
|
|
"""Fire a collection event by name. The daemon assembles the configured report
|
|
and sends S6F11. Values in `data` override current values for this one event.
|
|
"""
|
|
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
context.set_details('Method not implemented!')
|
|
raise NotImplementedError('Method not implemented!')
|
|
|
|
def SetAlarm(self, request, context):
|
|
"""Raise (S5F1 set) or clear an alarm by name.
|
|
"""
|
|
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
context.set_details('Method not implemented!')
|
|
raise NotImplementedError('Method not implemented!')
|
|
|
|
def ClearAlarm(self, request, context):
|
|
"""Missing associated documentation comment in .proto file."""
|
|
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
context.set_details('Method not implemented!')
|
|
raise NotImplementedError('Method not implemented!')
|
|
|
|
def GetControlState(self, request, context):
|
|
"""---- Universal: control state -------------------------------------------
|
|
|
|
Current GEM control state (ONLINE/LOCAL/REMOTE/OFFLINE).
|
|
"""
|
|
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
context.set_details('Method not implemented!')
|
|
raise NotImplementedError('Method not implemented!')
|
|
|
|
def RequestControlState(self, request, context):
|
|
"""Request a transition — e.g. an operator panel taking the tool OFFLINE for
|
|
maintenance, or back ONLINE. The daemon applies E30 rules and may decline.
|
|
"""
|
|
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
context.set_details('Method not implemented!')
|
|
raise NotImplementedError('Method not implemented!')
|
|
|
|
def Subscribe(self, request, context):
|
|
"""---- Universal: react to the host ---------------------------------------
|
|
|
|
Subscribe to everything the host asks of this equipment. The daemon streams
|
|
HostRequest messages for as long as the call stays open.
|
|
|
|
Delivery contract (v1):
|
|
- firehose: every subscriber receives every host request;
|
|
- NO buffering: a command arriving while no client is subscribed is
|
|
answered with its declarative ack from the equipment config (the
|
|
pre-daemon behaviour) and is NOT replayed on reconnect — the daemon
|
|
never tells the host "will finish later" for work no tool will do;
|
|
- when a Command does arrive here, the host has ALREADY been answered
|
|
with S2F42 HCACK=4; report the real outcome via FireEvent/SetAlarm.
|
|
"""
|
|
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
context.set_details('Method not implemented!')
|
|
raise NotImplementedError('Method not implemented!')
|
|
|
|
def CompleteCommand(self, request, context):
|
|
"""Report the outcome of a Command delivered on the stream, quoting its `id`.
|
|
NOTE the contract (SEMI-conformant, non-blocking): the daemon has ALREADY
|
|
answered the host with S2F42 HCACK=4 ("accepted, will finish later") when
|
|
it pushed the command onto the stream — the host's transaction is closed.
|
|
CompleteCommand therefore correlates/audits the command lifecycle; the
|
|
host learns the real outcome via the events/alarms you fire (FireEvent /
|
|
SetAlarm), exactly as E30 intends. A synchronous gating mode (tool decides
|
|
the HCACK before S2F42 goes out) is a possible v2 extension.
|
|
"""
|
|
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
context.set_details('Method not implemented!')
|
|
raise NotImplementedError('Method not implemented!')
|
|
|
|
def ReportProcessJob(self, request, context):
|
|
"""---- Jobs / Carriers: report progress of work the host asked for --------
|
|
Keyed by the durable id (job_id / carrier_id), not a per-message id — these
|
|
are long-lived objects you report against as the physical work proceeds.
|
|
|
|
E40 — job-based tools
|
|
"""
|
|
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
context.set_details('Method not implemented!')
|
|
raise NotImplementedError('Method not implemented!')
|
|
|
|
def ReportCarrier(self, request, context):
|
|
"""E87 — carrier-based tools. WAITING announces a physically-arrived
|
|
carrier (creates it; idempotent — re-announce updates the slot map);
|
|
IN_ACCESS / COMPLETE drive the access FSM. The host's S3F17 decisions
|
|
(ProceedWithCarrier / CancelCarrier) come back on the Subscribe stream
|
|
as CarrierAction.
|
|
"""
|
|
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
context.set_details('Method not implemented!')
|
|
raise NotImplementedError('Method not implemented!')
|
|
|
|
def ReportSubstrate(self, request, context):
|
|
"""E90 — substrate (wafer) tracking. Report each milestone of a wafer's
|
|
journey; the daemon drives the E90 FSMs and emits the standard CEIDs to
|
|
the host. ARRIVED creates the substrate. Only for tools that track
|
|
individual substrates.
|
|
"""
|
|
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
context.set_details('Method not implemented!')
|
|
raise NotImplementedError('Method not implemented!')
|
|
|
|
def ReportModule(self, request, context):
|
|
"""E157 — module process tracking. Report a module's execution state; the
|
|
daemon drives the E157 FSM and emits the standard CEIDs. The module is
|
|
auto-created on first report. Only for tools with tracked modules.
|
|
"""
|
|
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
context.set_details('Method not implemented!')
|
|
raise NotImplementedError('Method not implemented!')
|
|
|
|
def WatchHealth(self, request, context):
|
|
"""---- Diagnostics --------------------------------------------------------
|
|
|
|
Live daemon/link status: distinguishes "host went offline" from "cable
|
|
unplugged" from "spool filling up". Streams a snapshot on every change.
|
|
"""
|
|
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
context.set_details('Method not implemented!')
|
|
raise NotImplementedError('Method not implemented!')
|
|
|
|
def Describe(self, request, context):
|
|
"""Everything this equipment is configured with, by name — for tooling,
|
|
diagnostics, and client-side validation/autocomplete.
|
|
"""
|
|
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
context.set_details('Method not implemented!')
|
|
raise NotImplementedError('Method not implemented!')
|
|
|
|
def FlushSpool(self, request, context):
|
|
"""Flush the spool: purge=true discards queued messages, purge=false drains
|
|
them toward the host (requires a SELECTED session).
|
|
"""
|
|
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
context.set_details('Method not implemented!')
|
|
raise NotImplementedError('Method not implemented!')
|
|
|
|
def SendTerminalMessage(self, request, context):
|
|
"""Equipment-initiated operator message to the host (S10F1). Fails with
|
|
CANNOT_DO_NOW when no host is connected and stream 10 isn't spoolable.
|
|
"""
|
|
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
context.set_details('Method not implemented!')
|
|
raise NotImplementedError('Method not implemented!')
|
|
|
|
|
|
def add_EquipmentServicer_to_server(servicer, server):
|
|
rpc_method_handlers = {
|
|
'SetVariables': grpc.unary_unary_rpc_method_handler(
|
|
servicer.SetVariables,
|
|
request_deserializer=equipment__pb2.VariableUpdate.FromString,
|
|
response_serializer=equipment__pb2.Ack.SerializeToString,
|
|
),
|
|
'GetVariables': grpc.unary_unary_rpc_method_handler(
|
|
servicer.GetVariables,
|
|
request_deserializer=equipment__pb2.VariableQuery.FromString,
|
|
response_serializer=equipment__pb2.VariableSnapshot.SerializeToString,
|
|
),
|
|
'FireEvent': grpc.unary_unary_rpc_method_handler(
|
|
servicer.FireEvent,
|
|
request_deserializer=equipment__pb2.Event.FromString,
|
|
response_serializer=equipment__pb2.Ack.SerializeToString,
|
|
),
|
|
'SetAlarm': grpc.unary_unary_rpc_method_handler(
|
|
servicer.SetAlarm,
|
|
request_deserializer=equipment__pb2.Alarm.FromString,
|
|
response_serializer=equipment__pb2.Ack.SerializeToString,
|
|
),
|
|
'ClearAlarm': grpc.unary_unary_rpc_method_handler(
|
|
servicer.ClearAlarm,
|
|
request_deserializer=equipment__pb2.Alarm.FromString,
|
|
response_serializer=equipment__pb2.Ack.SerializeToString,
|
|
),
|
|
'GetControlState': grpc.unary_unary_rpc_method_handler(
|
|
servicer.GetControlState,
|
|
request_deserializer=equipment__pb2.Empty.FromString,
|
|
response_serializer=equipment__pb2.ControlState.SerializeToString,
|
|
),
|
|
'RequestControlState': grpc.unary_unary_rpc_method_handler(
|
|
servicer.RequestControlState,
|
|
request_deserializer=equipment__pb2.ControlStateRequest.FromString,
|
|
response_serializer=equipment__pb2.Ack.SerializeToString,
|
|
),
|
|
'Subscribe': grpc.unary_stream_rpc_method_handler(
|
|
servicer.Subscribe,
|
|
request_deserializer=equipment__pb2.SubscribeRequest.FromString,
|
|
response_serializer=equipment__pb2.HostRequest.SerializeToString,
|
|
),
|
|
'CompleteCommand': grpc.unary_unary_rpc_method_handler(
|
|
servicer.CompleteCommand,
|
|
request_deserializer=equipment__pb2.CommandResult.FromString,
|
|
response_serializer=equipment__pb2.Ack.SerializeToString,
|
|
),
|
|
'ReportProcessJob': grpc.unary_unary_rpc_method_handler(
|
|
servicer.ReportProcessJob,
|
|
request_deserializer=equipment__pb2.ProcessJobState.FromString,
|
|
response_serializer=equipment__pb2.Ack.SerializeToString,
|
|
),
|
|
'ReportCarrier': grpc.unary_unary_rpc_method_handler(
|
|
servicer.ReportCarrier,
|
|
request_deserializer=equipment__pb2.CarrierState.FromString,
|
|
response_serializer=equipment__pb2.Ack.SerializeToString,
|
|
),
|
|
'ReportSubstrate': grpc.unary_unary_rpc_method_handler(
|
|
servicer.ReportSubstrate,
|
|
request_deserializer=equipment__pb2.SubstrateReport.FromString,
|
|
response_serializer=equipment__pb2.Ack.SerializeToString,
|
|
),
|
|
'ReportModule': grpc.unary_unary_rpc_method_handler(
|
|
servicer.ReportModule,
|
|
request_deserializer=equipment__pb2.ModuleReport.FromString,
|
|
response_serializer=equipment__pb2.Ack.SerializeToString,
|
|
),
|
|
'WatchHealth': grpc.unary_stream_rpc_method_handler(
|
|
servicer.WatchHealth,
|
|
request_deserializer=equipment__pb2.Empty.FromString,
|
|
response_serializer=equipment__pb2.Health.SerializeToString,
|
|
),
|
|
'Describe': grpc.unary_unary_rpc_method_handler(
|
|
servicer.Describe,
|
|
request_deserializer=equipment__pb2.Empty.FromString,
|
|
response_serializer=equipment__pb2.EquipmentDescription.SerializeToString,
|
|
),
|
|
'FlushSpool': grpc.unary_unary_rpc_method_handler(
|
|
servicer.FlushSpool,
|
|
request_deserializer=equipment__pb2.SpoolFlushRequest.FromString,
|
|
response_serializer=equipment__pb2.Ack.SerializeToString,
|
|
),
|
|
'SendTerminalMessage': grpc.unary_unary_rpc_method_handler(
|
|
servicer.SendTerminalMessage,
|
|
request_deserializer=equipment__pb2.TerminalMessage.FromString,
|
|
response_serializer=equipment__pb2.Ack.SerializeToString,
|
|
),
|
|
}
|
|
generic_handler = grpc.method_handlers_generic_handler(
|
|
'secsgem.v1.Equipment', rpc_method_handlers)
|
|
server.add_generic_rpc_handlers((generic_handler,))
|
|
|
|
|
|
# This class is part of an EXPERIMENTAL API.
|
|
class Equipment(object):
|
|
"""=============================================================================
|
|
SECS/GEM Equipment API
|
|
|
|
The daemon *is* one piece of SEMI equipment: it owns the HSMS link to the
|
|
host (MES) and speaks GEM on your behalf. Your tool software connects as a
|
|
client and only ever does two things:
|
|
|
|
• tell the equipment about itself — set variables, fire events, raise alarms
|
|
• react to what the host asks for — receive commands/jobs, answer them
|
|
|
|
Everything SECS lives inside the daemon: message framing, report definitions,
|
|
the GEM state machines, timers, spooling. You need no SEMI knowledge to use
|
|
this API. Items are addressed by the human names from your equipment config
|
|
(e.g. "chamber_pressure"), never by numeric SVID / CEID / ALID.
|
|
|
|
CAPABILITY TIERS — wire up only what your equipment is:
|
|
• Universal — variables, events, alarms, control state, commands. Every tool.
|
|
• Carriers — E87 carrier/load-port flows. Only carrier-based equipment.
|
|
• Recipes — S7 process-program transfer. Only recipe-driven equipment.
|
|
• Jobs — E40 process jobs. Only job-based process/front-end equipment.
|
|
If a tier doesn't apply, you simply never receive its HostRequest variants and
|
|
never call its report RPCs.
|
|
=============================================================================
|
|
|
|
---- Universal: report state to the host --------------------------------
|
|
"""
|
|
|
|
@staticmethod
|
|
def SetVariables(request,
|
|
target,
|
|
options=(),
|
|
channel_credentials=None,
|
|
call_credentials=None,
|
|
insecure=False,
|
|
compression=None,
|
|
wait_for_ready=None,
|
|
timeout=None,
|
|
metadata=None):
|
|
return grpc.experimental.unary_unary(request, target, '/secsgem.v1.Equipment/SetVariables',
|
|
equipment__pb2.VariableUpdate.SerializeToString,
|
|
equipment__pb2.Ack.FromString,
|
|
options, channel_credentials,
|
|
insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
|
|
|
|
@staticmethod
|
|
def GetVariables(request,
|
|
target,
|
|
options=(),
|
|
channel_credentials=None,
|
|
call_credentials=None,
|
|
insecure=False,
|
|
compression=None,
|
|
wait_for_ready=None,
|
|
timeout=None,
|
|
metadata=None):
|
|
return grpc.experimental.unary_unary(request, target, '/secsgem.v1.Equipment/GetVariables',
|
|
equipment__pb2.VariableQuery.SerializeToString,
|
|
equipment__pb2.VariableSnapshot.FromString,
|
|
options, channel_credentials,
|
|
insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
|
|
|
|
@staticmethod
|
|
def FireEvent(request,
|
|
target,
|
|
options=(),
|
|
channel_credentials=None,
|
|
call_credentials=None,
|
|
insecure=False,
|
|
compression=None,
|
|
wait_for_ready=None,
|
|
timeout=None,
|
|
metadata=None):
|
|
return grpc.experimental.unary_unary(request, target, '/secsgem.v1.Equipment/FireEvent',
|
|
equipment__pb2.Event.SerializeToString,
|
|
equipment__pb2.Ack.FromString,
|
|
options, channel_credentials,
|
|
insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
|
|
|
|
@staticmethod
|
|
def SetAlarm(request,
|
|
target,
|
|
options=(),
|
|
channel_credentials=None,
|
|
call_credentials=None,
|
|
insecure=False,
|
|
compression=None,
|
|
wait_for_ready=None,
|
|
timeout=None,
|
|
metadata=None):
|
|
return grpc.experimental.unary_unary(request, target, '/secsgem.v1.Equipment/SetAlarm',
|
|
equipment__pb2.Alarm.SerializeToString,
|
|
equipment__pb2.Ack.FromString,
|
|
options, channel_credentials,
|
|
insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
|
|
|
|
@staticmethod
|
|
def ClearAlarm(request,
|
|
target,
|
|
options=(),
|
|
channel_credentials=None,
|
|
call_credentials=None,
|
|
insecure=False,
|
|
compression=None,
|
|
wait_for_ready=None,
|
|
timeout=None,
|
|
metadata=None):
|
|
return grpc.experimental.unary_unary(request, target, '/secsgem.v1.Equipment/ClearAlarm',
|
|
equipment__pb2.Alarm.SerializeToString,
|
|
equipment__pb2.Ack.FromString,
|
|
options, channel_credentials,
|
|
insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
|
|
|
|
@staticmethod
|
|
def GetControlState(request,
|
|
target,
|
|
options=(),
|
|
channel_credentials=None,
|
|
call_credentials=None,
|
|
insecure=False,
|
|
compression=None,
|
|
wait_for_ready=None,
|
|
timeout=None,
|
|
metadata=None):
|
|
return grpc.experimental.unary_unary(request, target, '/secsgem.v1.Equipment/GetControlState',
|
|
equipment__pb2.Empty.SerializeToString,
|
|
equipment__pb2.ControlState.FromString,
|
|
options, channel_credentials,
|
|
insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
|
|
|
|
@staticmethod
|
|
def RequestControlState(request,
|
|
target,
|
|
options=(),
|
|
channel_credentials=None,
|
|
call_credentials=None,
|
|
insecure=False,
|
|
compression=None,
|
|
wait_for_ready=None,
|
|
timeout=None,
|
|
metadata=None):
|
|
return grpc.experimental.unary_unary(request, target, '/secsgem.v1.Equipment/RequestControlState',
|
|
equipment__pb2.ControlStateRequest.SerializeToString,
|
|
equipment__pb2.Ack.FromString,
|
|
options, channel_credentials,
|
|
insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
|
|
|
|
@staticmethod
|
|
def Subscribe(request,
|
|
target,
|
|
options=(),
|
|
channel_credentials=None,
|
|
call_credentials=None,
|
|
insecure=False,
|
|
compression=None,
|
|
wait_for_ready=None,
|
|
timeout=None,
|
|
metadata=None):
|
|
return grpc.experimental.unary_stream(request, target, '/secsgem.v1.Equipment/Subscribe',
|
|
equipment__pb2.SubscribeRequest.SerializeToString,
|
|
equipment__pb2.HostRequest.FromString,
|
|
options, channel_credentials,
|
|
insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
|
|
|
|
@staticmethod
|
|
def CompleteCommand(request,
|
|
target,
|
|
options=(),
|
|
channel_credentials=None,
|
|
call_credentials=None,
|
|
insecure=False,
|
|
compression=None,
|
|
wait_for_ready=None,
|
|
timeout=None,
|
|
metadata=None):
|
|
return grpc.experimental.unary_unary(request, target, '/secsgem.v1.Equipment/CompleteCommand',
|
|
equipment__pb2.CommandResult.SerializeToString,
|
|
equipment__pb2.Ack.FromString,
|
|
options, channel_credentials,
|
|
insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
|
|
|
|
@staticmethod
|
|
def ReportProcessJob(request,
|
|
target,
|
|
options=(),
|
|
channel_credentials=None,
|
|
call_credentials=None,
|
|
insecure=False,
|
|
compression=None,
|
|
wait_for_ready=None,
|
|
timeout=None,
|
|
metadata=None):
|
|
return grpc.experimental.unary_unary(request, target, '/secsgem.v1.Equipment/ReportProcessJob',
|
|
equipment__pb2.ProcessJobState.SerializeToString,
|
|
equipment__pb2.Ack.FromString,
|
|
options, channel_credentials,
|
|
insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
|
|
|
|
@staticmethod
|
|
def ReportCarrier(request,
|
|
target,
|
|
options=(),
|
|
channel_credentials=None,
|
|
call_credentials=None,
|
|
insecure=False,
|
|
compression=None,
|
|
wait_for_ready=None,
|
|
timeout=None,
|
|
metadata=None):
|
|
return grpc.experimental.unary_unary(request, target, '/secsgem.v1.Equipment/ReportCarrier',
|
|
equipment__pb2.CarrierState.SerializeToString,
|
|
equipment__pb2.Ack.FromString,
|
|
options, channel_credentials,
|
|
insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
|
|
|
|
@staticmethod
|
|
def ReportSubstrate(request,
|
|
target,
|
|
options=(),
|
|
channel_credentials=None,
|
|
call_credentials=None,
|
|
insecure=False,
|
|
compression=None,
|
|
wait_for_ready=None,
|
|
timeout=None,
|
|
metadata=None):
|
|
return grpc.experimental.unary_unary(request, target, '/secsgem.v1.Equipment/ReportSubstrate',
|
|
equipment__pb2.SubstrateReport.SerializeToString,
|
|
equipment__pb2.Ack.FromString,
|
|
options, channel_credentials,
|
|
insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
|
|
|
|
@staticmethod
|
|
def ReportModule(request,
|
|
target,
|
|
options=(),
|
|
channel_credentials=None,
|
|
call_credentials=None,
|
|
insecure=False,
|
|
compression=None,
|
|
wait_for_ready=None,
|
|
timeout=None,
|
|
metadata=None):
|
|
return grpc.experimental.unary_unary(request, target, '/secsgem.v1.Equipment/ReportModule',
|
|
equipment__pb2.ModuleReport.SerializeToString,
|
|
equipment__pb2.Ack.FromString,
|
|
options, channel_credentials,
|
|
insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
|
|
|
|
@staticmethod
|
|
def WatchHealth(request,
|
|
target,
|
|
options=(),
|
|
channel_credentials=None,
|
|
call_credentials=None,
|
|
insecure=False,
|
|
compression=None,
|
|
wait_for_ready=None,
|
|
timeout=None,
|
|
metadata=None):
|
|
return grpc.experimental.unary_stream(request, target, '/secsgem.v1.Equipment/WatchHealth',
|
|
equipment__pb2.Empty.SerializeToString,
|
|
equipment__pb2.Health.FromString,
|
|
options, channel_credentials,
|
|
insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
|
|
|
|
@staticmethod
|
|
def Describe(request,
|
|
target,
|
|
options=(),
|
|
channel_credentials=None,
|
|
call_credentials=None,
|
|
insecure=False,
|
|
compression=None,
|
|
wait_for_ready=None,
|
|
timeout=None,
|
|
metadata=None):
|
|
return grpc.experimental.unary_unary(request, target, '/secsgem.v1.Equipment/Describe',
|
|
equipment__pb2.Empty.SerializeToString,
|
|
equipment__pb2.EquipmentDescription.FromString,
|
|
options, channel_credentials,
|
|
insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
|
|
|
|
@staticmethod
|
|
def FlushSpool(request,
|
|
target,
|
|
options=(),
|
|
channel_credentials=None,
|
|
call_credentials=None,
|
|
insecure=False,
|
|
compression=None,
|
|
wait_for_ready=None,
|
|
timeout=None,
|
|
metadata=None):
|
|
return grpc.experimental.unary_unary(request, target, '/secsgem.v1.Equipment/FlushSpool',
|
|
equipment__pb2.SpoolFlushRequest.SerializeToString,
|
|
equipment__pb2.Ack.FromString,
|
|
options, channel_credentials,
|
|
insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
|
|
|
|
@staticmethod
|
|
def SendTerminalMessage(request,
|
|
target,
|
|
options=(),
|
|
channel_credentials=None,
|
|
call_credentials=None,
|
|
insecure=False,
|
|
compression=None,
|
|
wait_for_ready=None,
|
|
timeout=None,
|
|
metadata=None):
|
|
return grpc.experimental.unary_unary(request, target, '/secsgem.v1.Equipment/SendTerminalMessage',
|
|
equipment__pb2.TerminalMessage.SerializeToString,
|
|
equipment__pb2.Ack.FromString,
|
|
options, channel_credentials,
|
|
insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
|