Struct RiPythonModuleAdapter 

pub struct RiPythonModuleAdapter {
    pub name: String,
    pub is_critical: bool,
    pub priority: i32,
    pub dependencies: Vec<String>,
}

Python module adapter that implements RiModule trait.

This structure enables Python modules to integrate with the Ri module system by implementing the AsyncServiceModule trait. Python code can create instances of this adapter with custom configuration, and they will participate in the module lifecycle just like Rust-native modules.

Thread Safety

This structure is designed to be safely used across threads when combined with the appropriate Python GIL management. The underlying implementation ensures proper synchronization during lifecycle callbacks.

Lifecycle Methods

All lifecycle methods (init, before_start, start, after_start, before_shutdown, shutdown, after_shutdown) have default implementations that return Ok(()), allowing Python modules to override only the methods they need.

Python Usage

 

class MyPythonModule:
    def name(&self):
        return "python_module"

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

adapter = dms.RiPythonModuleAdapter(name="my_module")
adapter.name = "python_module"

Fields

name: String

is_critical: bool

priority: i32

dependencies: Vec<String>

Trait Implementations

impl AsyncServiceModule for RiPythonModuleAdapter

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 RiPythonModuleAdapter

fn clone(&self) -> RiPythonModuleAdapter

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'py> IntoPyObject<'py> for RiPythonModuleAdapter

type Target = RiPythonModuleAdapter

The Python output type

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

type Frozen = False

Whether the pyclass is frozen.

impl PyClassImpl for RiPythonModuleAdapter

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"Python module adapter that implements RiModule trait.\n\nThis structure enables Python modules to integrate with the Ri module system\nby implementing the `AsyncServiceModule` trait. Python code can create instances\nof this adapter with custom configuration, and they will participate in the\nmodule lifecycle just like Rust-native modules.\n\n## Thread Safety\n\nThis structure is designed to be safely used across threads when combined\nwith the appropriate Python GIL management. The underlying implementation\nensures proper synchronization during lifecycle callbacks.\n\n## Lifecycle Methods\n\nAll lifecycle methods (`init`, `before_start`, `start`, `after_start`,\n`before_shutdown`, `shutdown`, `after_shutdown`) have default implementations\nthat return `Ok(())`, allowing Python modules to override only the methods\nthey need.\n\n## Python Usage\n\n```python\n\n\nclass MyPythonModule:\n def name(&self):\n return \"python_module\"\n\n async def start(&self, ctx):\n print(\"Starting Python module\")\n return None\n\nadapter = dms.RiPythonModuleAdapter(name=\"my_module\")\nadapter.name = \"python_module\"\n```\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<RiPythonModuleAdapter>

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 RiPythonModuleAdapter

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

impl PyMethods<RiPythonModuleAdapter> for PyClassImplCollector<RiPythonModuleAdapter>

fn py_methods(self) -> &'static PyClassItems

impl PyTypeInfo for RiPythonModuleAdapter

const NAME: &'static str = "RiPythonModuleAdapter"

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 RiPythonModuleAdapter

impl ExtractPyClassWithClone for RiPythonModuleAdapter