Struct RiPythonAsyncServiceModule 

pub struct RiPythonAsyncServiceModule { /* private fields */ }

Python wrapper for asynchronous AsyncServiceModule trait.

This structure provides a Python-accessible representation of asynchronous service modules. It enables Python code to define async modules that integrate with Ri’s module lifecycle system using non-blocking operations.

Asynchronous Execution

Asynchronous modules use Rust’s async/await model and are executed on the Tokio runtime. This enables non-blocking I/O operations and concurrent execution of multiple async modules without thread blocking.

Tokio Runtime

The async modules execute within the Tokio runtime that is managed by the Ri application runtime. This provides efficient task scheduling and native support for async I/O operations.

Python Integration

When using Python with pyo3, asynchronous methods should be defined using async def syntax. The Python runtime must be properly initialized before async operations can be performed.

Python Usage

 

class MyAsyncModule:
    async def name(&self):
        return "async_module"

    async def start(&self, ctx):
        print("Starting async module")
        return None

module = dms.RiPythonAsyncServiceModule(name="my_async")
module.priority = 100
module.dependencies = ["config", "logger"]

Implementations

impl RiPythonAsyncServiceModule

pub fn name(&self) -> String

pub fn set_name(&mut self, name: String)

pub fn is_critical(&self) -> bool

pub fn set_is_critical(&mut self, is_critical: bool)

pub fn priority(&self) -> i32

pub fn set_priority(&mut self, priority: i32)

pub fn dependencies(&self) -> Vec<String>

pub fn set_dependencies(&mut self, dependencies: Vec<String>)

Trait Implementations

impl AsyncServiceModule for RiPythonAsyncServiceModule

fn name(&self) -> &str

Returns the name of the internal async service module.

fn is_critical(&self) -> bool

Indicates if the internal module is critical to the operation of the system.

fn priority(&self) -> i32

Returns the priority of the internal module.

fn dependencies(&self) -> Vec<&str>

Returns the list of module dependencies.

fn init<'life0, 'life1, 'async_trait>( &'life0 mut self, _ctx: &'life1 mut RiServiceContext, ) -> Pin<Box<dyn Future<Output = RiResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Initializes the internal async service module.

fn before_start<'life0, 'life1, 'async_trait>( &'life0 mut self, _ctx: &'life1 mut RiServiceContext, ) -> Pin<Box<dyn Future<Output = RiResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Prepares the internal module for startup.

fn start<'life0, 'life1, 'async_trait>( &'life0 mut self, _ctx: &'life1 mut RiServiceContext, ) -> Pin<Box<dyn Future<Output = RiResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Starts the internal async service module.

fn after_start<'life0, 'life1, 'async_trait>( &'life0 mut self, _ctx: &'life1 mut RiServiceContext, ) -> Pin<Box<dyn Future<Output = RiResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Performs post-startup operations for the internal module.

fn before_shutdown<'life0, 'life1, 'async_trait>( &'life0 mut self, _ctx: &'life1 mut RiServiceContext, ) -> Pin<Box<dyn Future<Output = RiResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Prepares the internal module for shutdown.

fn shutdown<'life0, 'life1, 'async_trait>( &'life0 mut self, _ctx: &'life1 mut RiServiceContext, ) -> Pin<Box<dyn Future<Output = RiResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Shuts down the internal async service module.

fn after_shutdown<'life0, 'life1, 'async_trait>( &'life0 mut self, _ctx: &'life1 mut RiServiceContext, ) -> Pin<Box<dyn Future<Output = RiResult<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Performs post-shutdown cleanup for the internal module.

impl Clone for RiPythonAsyncServiceModule

fn clone(&self) -> RiPythonAsyncServiceModule

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'py> IntoPyObject<'py> for RiPythonAsyncServiceModule

type Target = RiPythonAsyncServiceModule

The Python output type

type Output = Bound<'py, <RiPythonAsyncServiceModule 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 RiPythonAsyncServiceModule

type Frozen = False

Whether the pyclass is frozen.

impl PyClassBaseType for RiPythonAsyncServiceModule

type LayoutAsBase = PyClassObject<RiPythonAsyncServiceModule>

type BaseNativeType = <RiPythonAsyncServiceModule as PyClassImpl>::BaseNativeType

type Initializer = PyClassInitializer<RiPythonAsyncServiceModule>

type PyClassMutability = <RiPythonAsyncServiceModule as PyClassImpl>::PyClassMutability

impl PyClassImpl for RiPythonAsyncServiceModule

const IS_BASETYPE: bool = true

#[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 = /// ```

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<RiPythonAsyncServiceModule>

This handles following two situations:

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 PyClassNewTextSignature for RiPythonAsyncServiceModule

const TEXT_SIGNATURE: &'static str = "(name)"

impl PyMethods<RiPythonAsyncServiceModule> for PyClassImplCollector<RiPythonAsyncServiceModule>

fn py_methods(self) -> &'static PyClassItems

impl PyTypeInfo for RiPythonAsyncServiceModule

const NAME: &'static str = "RiPythonAsyncServiceModule"

Class name.

const MODULE: Option<&'static str> = ::core::option::Option::None

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 RiPythonAsyncServiceModule

impl ExtractPyClassWithClone for RiPythonAsyncServiceModule