rustpy-ml 0.1.0

A Rust library for seamless Python integration, enabling ML workflows with type safety
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

@startuml Rustpy Architecture
!theme plain
skinparam componentStyle rectangle

title Rustpy: Python-Rust Integration Architecture

package "User Code" {
  [Rust Application] as RustApp
}

package "Rustpy Library" {
  package "Macro Layer" {
    [python! Macro] as PythonMacro
    [py_exec! Macro] as ExecMacro
    [py_eval! Macro] as EvalMacro
    [py_locals! Macro] as LocalsMacro
  }
  
  package "Runtime Layer" {
    [Runtime Manager] as Runtime
    [Global State] as GlobalState
    note right of GlobalState
      OnceCell<Mutex<Python>>
      Thread-safe Python instance
    end note
  }
  
  package "Type Conversion" {
    [IntoPython Trait] as IntoPython
    [FromPython Trait] as FromPython
    [Type Converters] as Converters
    note right of Converters
      • String ↔ PyString
      • i32/i64 ↔ PyInt
      • f32/f64 ↔ PyFloat
      • bool ↔ PyBool
      • Vec<T> ↔ PyList
      • HashMap ↔ PyDict
    end note
  }
  
  package "Error Handling" {
    [RustpyError] as Error
  }
}

package "PyO3 Layer" {
  [Python FFI] as PyO3FFI
  [Python Types] as PyTypes
  [GIL Management] as GIL
}

package "Python Runtime" {
  [CPython] as CPython
  [Python Modules] as PyModules
  [NumPy] as NumPy
  [scikit-learn] as SKLearn
}

' Relationships
RustApp --> PythonMacro : uses macros
RustApp --> ExecMacro
RustApp --> EvalMacro
RustApp --> LocalsMacro

PythonMacro --> Runtime : initializes
ExecMacro --> Runtime : executes code
EvalMacro --> Runtime : evaluates expression
LocalsMacro --> Runtime : creates locals dict

Runtime --> GlobalState : manages
Runtime --> PyO3FFI : calls
Runtime --> IntoPython : uses
Runtime --> FromPython : uses

IntoPython --> Converters
FromPython --> Converters
Converters --> PyO3FFI : converts via

Runtime --> Error : returns
Error --> RustApp : propagates

PyO3FFI --> GIL : acquires
PyO3FFI --> PyTypes : provides
PyO3FFI --> CPython : FFI bindings

CPython --> PyModules : imports
PyModules --> NumPy
PyModules --> SKLearn

note bottom of RustApp
  Example Usage:
  python! {
    import numpy as np
    data = np.array([1, 2, 3])
  }
end note

@enduml