Struct PyInstance 

pub struct PyInstance { /* private fields */ }

Implementations

impl PyInstance

pub fn actor_id(&self) -> PyActorId

impl PyInstance

pub fn into_instance(self) -> Instance<PythonActor>

Methods from Deref<Target = Instance<PythonActor>>

pub fn self_id(&self) -> &ActorId

This instance’s actor ID.

pub fn introspect_payload(&self) -> IntrospectResult

Snapshot of this actor’s introspection payload.

Returns an IntrospectResult built from live InstanceCell state, without going through the actor message loop. This is safe to call from within a handler on the same actor (no self-send deadlock).

The snapshot is best-effort: it reflects framework-owned state (status, message count, flight recorder, supervision children) at the instant of the call. parent is left as None — callers are responsible for setting topology context.

Note: this acquires a write lock on the flight recorder spool and clones its contents. Suitable for occasional introspection requests, not for hot paths.

pub fn publish_attrs(&self, attrs: Attrs)

Publish domain-specific properties for introspection.

Publish a complete Attrs bag for introspection. Replaces any previously published attrs.

Debug builds assert that every key in the bag is tagged with the INTROSPECT meta-attribute.

pub fn publish_attr<T>(&self, key: Key<T>, value: T)

where T: AttrValue,

Publish a single attr key-value pair for introspection. Merges into existing published attrs (insert or overwrite).

Debug builds assert that the key is tagged with the INTROSPECT meta-attribute.

pub fn set_system(&self)

Mark this actor as system/infrastructure. System actors are hidden by default in the TUI (toggled via s).

pub fn set_query_child_handler( &self, handler: impl Fn(&Reference) -> IntrospectResult + Send + Sync + 'static, )

Register a callback for resolving non-addressable children.

The callback runs on the actor’s introspect task (not the actor loop), so it must be Send + Sync and must not access actor-mutable state. Capture cloned Proc references.

Only HostAgent uses this today — for resolving system procs that have no independent ProcAgent.

pub fn stop(&self, reason: &str) -> Result<(), ActorError>

Signal the actor to stop.

pub fn abort(&self, reason: &str) -> Result<(), ActorError>

Signal the actor to abort with a provided reason.

pub fn open_port<M>(&self) -> (PortHandle<M>, PortReceiver<M>)

where M: Message,

Open a new port that accepts M-typed messages. The returned port may be freely cloned, serialized, and passed around. The returned receiver should only be retained by the actor responsible for processing the delivered messages.

pub fn open_once_port<M>(&self) -> (OncePortHandle<M>, OncePortReceiver<M>)

where M: Message,

Open a new one-shot port that accepts M-typed messages. The returned port may be used to send a single message; ditto the receiver may receive a single message.

pub fn locals(&self) -> &ActorLocalStorage

Get the per-instance local storage.

pub fn post(&self, port_id: PortId, headers: Flattrs, message: Any)

Send a message to the actor running on the proc.

pub fn self_message_with_delay<M>( &self, message: M, delay: Duration, ) -> Result<(), ActorError>

where M: Message, A: Handler<M>,

Send a message to the actor itself with a delay usually to trigger some event.

pub async fn handle_supervision_event( &self, actor: &mut A, supervision_event: ActorSupervisionEvent, ) -> Result<(), ActorError>

Handle a supervision event using the provided actor.

pub fn spawn<C>(&self, actor: C) -> Result<ActorHandle<C>, Error>

where C: Actor,

Spawn on child on this instance.

pub fn spawn_with_name<C>( &self, name: &str, actor: C, ) -> Result<ActorHandle<C>, Error>

where C: Actor,

Spawn a named child actor on this instance. The child gets a descriptive name in its ActorId instead of inheriting this instance’s name. Supervision linkage is preserved.

pub fn child(&self) -> Result<(Instance<()>, ActorHandle<()>), Error>

Create a new direct child instance.

pub fn port<M>(&self) -> PortHandle<M>

where M: Message, A: Handler<M>,

Return a handle port handle representing the actor’s message handler for M-typed messages.

pub fn handle(&self) -> ActorHandle<A>

The ActorHandle corresponding to this instance.

pub fn bind<R>(&self) -> ActorRef<R>

where R: Binds<A>,

The owning actor ref.

pub fn proc(&self) -> &Proc

The owning proc.

pub fn sequencer(&self) -> &Sequencer

Return this instance’s sequencer.

pub fn instance_id(&self) -> Uuid

Return this instance’s ID.

pub fn parent_handle<P>(&self) -> Option<ActorHandle<P>>

where P: Actor,

Return a handle to this instance’s parent actor, if it has one.

Trait Implementations

impl Clone for PyInstance

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Deref for PyInstance

type Target = Instance<PythonActor>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<I: Actor<A = PythonActor>> From<I> for PyInstance

fn from(ins: I) -> Self

Converts to this type from the input type.

impl<'py> IntoPyObject<'py> for PyInstance

type Target = PyInstance

The Python output type

type Output = Bound<'py, <PyInstance as IntoPyObject<'py>>::Target>

The smart pointer type to use.

type Error = PyErr

The type returned in the event of a conversion error.

fn into_pyobject( self, py: Python<'py>, ) -> Result<<Self as IntoPyObject<'_>>::Output, <Self as IntoPyObject<'_>>::Error>

Performs the conversion.

impl PyClass for PyInstance

type Frozen = False

Whether the pyclass is frozen.

impl PyClassImpl for PyInstance

const IS_BASETYPE: bool = false

#[pyclass(subclass)]

const IS_SUBCLASS: bool = false

#[pyclass(extends=…)]

const IS_MAPPING: bool = false

#[pyclass(mapping)]

const IS_SEQUENCE: bool = false

#[pyclass(sequence)]

const IS_IMMUTABLE_TYPE: bool = false

#[pyclass(immutable_type)]

const RAW_DOC: &'static CStr = c"\x00"

Docstring for the class provided on the struct or enum.

const DOC: &'static CStr

Fully rendered class doc, including the text_signature if a constructor is defined.

type BaseType = PyAny

Base class

type ThreadChecker = SendablePyClass<PyInstance>

This handles following two situations:

type Inventory = Pyo3MethodsInventoryForPyInstance

type PyClassMutability = <<PyAny as PyClassBaseType>::PyClassMutability as PyClassMutability>::MutableChild

Immutable or mutable

type Dict = PyClassDummySlot

Specify this class has #[pyclass(dict)] or not.

type WeakRef = PyClassDummySlot

Specify this class has #[pyclass(weakref)] or not.

type BaseNativeType = PyAny

The closest native ancestor. This is PyAny by default, and when you declare #[pyclass(extends=PyDict)], it’s PyDict.

fn items_iter() -> PyClassItemsIter

fn lazy_type_object() -> &'static LazyTypeObject<Self>

fn dict_offset() -> Option<isize>

fn weaklist_offset() -> Option<isize>

impl<'a, 'holder, 'py> PyFunctionArgument<'a, 'holder, 'py, false> for &'holder PyInstance

type Holder = Option<PyClassGuard<'a, PyInstance>>

fn extract( obj: &'a Bound<'py, PyAny>, holder: &'holder mut Self::Holder, ) -> PyResult<Self>

impl<'a, 'holder, 'py> PyFunctionArgument<'a, 'holder, 'py, false> for &'holder mut PyInstance

type Holder = Option<PyClassGuardMut<'a, PyInstance>>

fn extract( obj: &'a Bound<'py, PyAny>, holder: &'holder mut Self::Holder, ) -> PyResult<Self>

impl PyTypeInfo for PyInstance

const NAME: &'static str = "Instance"

Class name.

const MODULE: Option<&'static str>

Module name, if any.

fn type_object_raw(py: Python<'_>) -> *mut PyTypeObject

Returns the PyTypeObject instance for this type.

fn type_object(py: Python<'_>) -> Bound<'_, PyType>

Returns the safe abstraction over the type object.

fn is_type_of(object: &Bound<'_, PyAny>) -> bool

Checks if object is an instance of this type or a subclass of this type.

fn is_exact_type_of(object: &Bound<'_, PyAny>) -> bool

Checks if object is an instance of this type.

impl DerefToPyAny for PyInstance