stinger-ipc 0.0.5__py3-none-any.whl → 0.0.7__py3-none-any.whl

stingeripc/templates/rust/server/src/lib.rs.jinja2

@@ -5,39 +5,38 @@ on the next generation.
 This is the Server for the {{stinger.name}} interface.
 */
 
-extern crate paho_mqtt as mqtt;
-use connection::{MessagePublisher, Connection, ReceivedMessage};
+use mqttier::{MqttierClient{%if stinger.methods|length > 0 or stinger.properties|length > 0 %}, ReceivedMessage{%endif%}};
 
 #[allow(unused_imports)]
-use connection::payloads::{*, MethodResultCode};
-
+use {{stinger.rust.common_package_name}}::payloads::{*, MethodResultCode};
+{%if stinger.methods|length > 0 or stinger.properties|length > 0 %}
+use serde_json;
 use std::sync::{Arc, Mutex};
-use tokio::sync::{mpsc};
-use tokio::join;
+use tokio::sync::mpsc;
+{%endif%}
 use tokio::task::JoinError;
-use serde::{Serialize, Deserialize};
-use serde_json;
 
+{%if stinger.methods|length > 0 or stinger.properties|length > 0 %}
 /// This struct is used to store all the MQTTv5 subscription ids
 /// for the subscriptions the client will make.
 #[derive(Clone, Debug)]
 struct {{stinger.name | UpperCamelCase }}ServerSubscriptionIds {
     {%for method_name, method in stinger.methods.items()-%}
-    {{method_name | snake_case}}_method_req: i32,
+    {{method_name | snake_case}}_method_req: usize,
     {%endfor%}
     {%for prop_name, prop in stinger.properties.items()-%}{%if not prop.read_only %}
-    {{prop_name | snake_case}}_property_update: i32,
+    {{prop_name | snake_case}}_property_update: usize,
     {%endif%}{%endfor%}
 }
-
+{%if stinger.methods|length > 0 %}
 #[derive(Clone)]
 struct {{stinger.name | UpperCamelCase }}ServerMethodHandlers {
     {%for method_name, method in stinger.methods.items()-%}
     /// Pointer to a function to handle the {{method_name}} method request.
     method_handler_for_{{method_name|snake_case}}: Arc<Mutex<Box<dyn Fn({%for arg in method.arg_list%}{{arg.rust_type}}{%if not loop.last%}, {%endif%}{%endfor%})->Result<{{method.return_value_rust_type}}, MethodResultCode> + Send>>>,
     {%endfor%}
-}
-
+}{%endif%}{# method handlers struct #}
+{%if stinger.properties | length > 0%}
 #[derive(Clone)]
 struct {{stinger.name | UpperCamelCase}}Properties {
     {%for prop_name, prop in stinger.properties.items()-%}
@@ -49,63 +48,64 @@ struct {{stinger.name | UpperCamelCase}}Properties {
     {%endif%}
     {%-endfor%}
 }
+{%endif%}
+{%endif%}{# any methods or properties #}
 
-pub struct {{stinger.name | UpperCamelCase}}Server {
+pub struct {{stinger.rust.server_struct_name}} {
+    mqttier_client: MqttierClient,
+    {%if stinger.methods|length > 0 or stinger.properties|length > 0 %}
     /// Temporarily holds the receiver for the MPSC channel.  The Receiver will be moved
     /// to a process loop when it is needed.  MQTT messages will be received with this.
     msg_streamer_rx: Option<mpsc::Receiver<ReceivedMessage>>,
 
     /// The Sender side of MQTT messages that are received from the broker.  This tx
     /// side is cloned for each subscription made.
+    #[allow(dead_code)]
     msg_streamer_tx: mpsc::Sender<ReceivedMessage>,
-
-    /// Through this MessagePublisher object, we can publish messages to MQTT.
-    msg_publisher: MessagePublisher,
-
+    {%endif%}
+    {%if stinger.methods|length > 0 %}
     /// Struct contains all the handlers for the various methods.
-    method_handlers: {{stinger.name | UpperCamelCase }}ServerMethodHandlers,
+    method_handlers: {{stinger.name | UpperCamelCase }}ServerMethodHandlers,{%endif%}
     {%if stinger.properties|length > 0%}
     /// Struct contains all the properties.
     properties: {{stinger.name | UpperCamelCase}}Properties,
     {%endif%}
+    {%if stinger.methods|length > 0 or stinger.properties|length > 0 %}
     /// Subscription IDs for all the subscriptions this makes.
     subscription_ids: {{stinger.name | UpperCamelCase }}ServerSubscriptionIds,
+    {%endif%}
 
     /// Copy of MQTT Client ID
-    client_id: String,
+    #[allow(dead_code)]
+    pub client_id: String,
 }
 
-impl {{stinger.name | UpperCamelCase}}Server {
-    pub async fn new(connection: &mut Connection) -> Self {
-        let _ = connection.connect().await.expect("Could not connect to MQTT broker");
-
-        //let interface_info = String::from(r#"{{stinger.interface_info.1 | tojson}}"#);
-        //connection.publish("{{stinger.interface_info.0}}".to_string(), interface_info, 1).await;
-
-        // Create a channel for messages to get from the Connection object to this {{stinger.name | UpperCamelCase }}Client object.
+impl {{stinger.rust.server_struct_name}} {
+    pub async fn new(connection: &mut MqttierClient) -> Self {
+        {%if stinger.methods|length > 0 or stinger.properties|length > 0 %}
+        // Create a channel for messages to get from the MqttierClient object to this {{stinger.rust.server_struct_name}} object.
         // The Connection object uses a clone of the tx side of the channel.
-        let (message_received_tx, message_received_rx) = mpsc::channel(64);
-
-        let publisher = connection.get_publisher();
+        let (message_received_tx, message_received_rx) = mpsc::channel::<ReceivedMessage>(64);
 
         // Create method handler struct
         {%for method_name, method in stinger.methods.items()-%}
-        let subscription_id_{{method_name | snake_case}}_method_req = connection.subscribe("{{method.topic}}", message_received_tx.clone()).await;
-        let subscription_id_{{method_name | snake_case}}_method_req = subscription_id_{{method_name | snake_case}}_method_req.unwrap_or_else(|_| -1);
+        let subscription_id_{{method_name | snake_case}}_method_req = connection.subscribe("{{method.topic}}".to_string(), 2, message_received_tx.clone()).await;
+        let subscription_id_{{method_name | snake_case}}_method_req = subscription_id_{{method_name | snake_case}}_method_req.unwrap_or_else(|_| usize::MAX);
         {%endfor%}
-
         {%for prop_name, prop in stinger.properties.items()-%}{%if not prop.read_only %}
-        let subscription_id_{{prop_name | snake_case}}_property_update = connection.subscribe("{{prop.update_topic}}", message_received_tx.clone()).await;
-        let subscription_id_{{prop_name | snake_case}}_property_update = subscription_id_{{prop_name | snake_case}}_property_update.unwrap_or_else(|_| -1);
+        let subscription_id_{{prop_name | snake_case}}_property_update = connection.subscribe("{{prop.update_topic}}".to_string(), 2, message_received_tx.clone()).await;
+        let subscription_id_{{prop_name | snake_case}}_property_update = subscription_id_{{prop_name | snake_case}}_property_update.unwrap_or_else(|_| usize::MAX);
+        {%else-%}
         {%endif%}{%endfor%}
-
+        {%if stinger.methods | length > 0 %}
         // Create structure for method handlers.
         let method_handlers = {{stinger.name | UpperCamelCase }}ServerMethodHandlers {
             {%-for method_name, method in stinger.methods.items()-%}
             method_handler_for_{{method_name|snake_case}}: Arc::new(Mutex::new(Box::new( |{%for arg in method.arg_list-%}_{{loop.index}}{%if not loop.last%}, {%endif%}{%endfor%}| { Err(MethodResultCode::ServerError) } ))),
             {%endfor%}
         };
-
+        {%endif%}{# method handlers #}
+        
         // Create structure for subscription ids.
         let sub_ids = {{stinger.name | UpperCamelCase }}ServerSubscriptionIds {
             {%for method_name, method in stinger.methods.items()-%}
@@ -115,6 +115,7 @@ impl {{stinger.name | UpperCamelCase}}Server {
             {{prop_name | snake_case}}_property_update: subscription_id_{{prop_name | snake_case}}_property_update,
             {%endif%}{%endfor%}
         };
+        {%endif%}
 
         {%if stinger.properties|length > 0%}
         let property_values = {{stinger.name | UpperCamelCase}}Properties {
@@ -129,56 +130,62 @@ impl {{stinger.name | UpperCamelCase}}Server {
         };
         {%endif%}
 
-        {{stinger.name | UpperCamelCase}}Server {
-
+        {{stinger.rust.server_struct_name}} {
+            mqttier_client: connection.clone(),
+            {%if stinger.methods|length > 0 or stinger.properties|length > 0 %}
             msg_streamer_rx: Some(message_received_rx),
-            msg_streamer_tx: message_received_tx,
-            msg_publisher: publisher,
-            method_handlers: method_handlers,{%if stinger.properties|length > 0%}
+            msg_streamer_tx: message_received_tx,{%if stinger.methods | length > 0 %}
+            method_handlers: method_handlers,{%endif%}{%if stinger.properties | length > 0 %}
             properties: property_values,{%endif%}
             subscription_ids: sub_ids,
+            {%endif%}
             client_id: connection.client_id.to_string(),
         }
     }
 
     {%for sig_name, sig in stinger.signals.items()-%}
+    /// Emits the {{sig_name}} signal with the given arguments.
     pub async fn emit_{{sig_name|snake_case}}(&mut self, {%for arg in sig.arg_list%}{{arg.name|snake_case}}: {{arg.rust_type}}{%if not loop.last%}, {%endif%}{%endfor%}) {
-        let data = connection::payloads::{{sig_name|UpperCamelCase}}SignalPayload {
+        let data = {{sig_name|UpperCamelCase}}SignalPayload {
             {%for arg in sig.arg_list%}
             {{arg.name}}: {{arg.name|snake_case}},
             {%endfor%}
         };
-        self.msg_publisher.publish_structure("{{sig.topic}}".to_string(), &data).await;
+        let _ = self.mqttier_client.publish_state("{{sig.topic}}".to_string(), &data, 1).await;
     }
     {%endfor%}
 
     {%for method_name, method in stinger.methods.items()-%}
+    /// Sets the function to be called when a request for the {{method_name}} method is received.
     pub fn set_method_handler_for_{{method_name|snake_case}}(&mut self, cb: impl Fn({%for arg in method.arg_list%}{{arg.rust_type}}{%if not loop.last%}, {%endif%}{%endfor%})->Result<{{method.return_value_rust_type}}, MethodResultCode> + 'static + Send) {
         self.method_handlers.method_handler_for_{{method_name|snake_case}} = Arc::new(Mutex::new(Box::new(cb)));
     }
     {%endfor%}
 
-
     {%for method_name, method in stinger.methods.items()-%}
-    async fn handle_{{method_name|snake_case}}_request(publisher: &mut MessagePublisher, handlers: &mut {{stinger.name | UpperCamelCase }}ServerMethodHandlers, msg: mqtt::Message) {
-        let props = msg.properties();
-        let opt_corr_id_bin: Option<Vec<u8>> = props.get_binary(mqtt::PropertyCode::CorrelationData);
-        let opt_resp_topic = props.get_string(mqtt::PropertyCode::ResponseTopic);
-        let payload_str = msg.payload_str();
-        let payload = serde_json::from_str::<{{method_name | UpperCamelCase}}RequestObject>(&payload_str).unwrap();
-
+    /// Handles a request message for the {{method_name}} method.
+    async fn handle_{{method_name|snake_case}}_request(publisher: MqttierClient, handlers: &mut {{stinger.name | UpperCamelCase }}ServerMethodHandlers, msg: ReceivedMessage) {
+        let opt_corr_data = msg.correlation_data;
+        let opt_resp_topic = msg.response_topic;
+        {%if method.return_value_type != false -%}
+        let payload_vec = msg.payload;
+        let payload = serde_json::from_slice::<{{method_name | UpperCamelCase}}RequestObject>(&payload_vec).unwrap();
+        {%endif%}
         // call the method handler
         let rv: {{method.return_value_rust_type}} = {
             let func_guard = handlers.method_handler_for_{{method_name|snake_case}}.lock().unwrap();
             (*func_guard)({%for arg in method.arg_list%}payload.{{arg.name}}{%if not loop.last%}, {%endif%}{%endfor%}).unwrap()
         };
+
         {%-if method.return_value_type == "primitive" -%}
         let rv = {{method_name | UpperCamelCase}}ReturnValue {
             {{method.return_value_property_name}}: rv,
         };
         {%endif%}
+
         if let Some(resp_topic) = opt_resp_topic {
-            publisher.publish_response_structure(resp_topic, &rv, opt_corr_id_bin).await.expect("Failed to publish response structure");
+            let corr_data = opt_corr_data.unwrap_or_default();
+            publisher.publish_response(resp_topic, &rv, corr_data).await.expect("Failed to publish response structure");
         } else {
             eprintln!("No response topic found in message properties.");
         }
@@ -186,21 +193,21 @@ impl {{stinger.name | UpperCamelCase}}Server {
     {%endfor%}
 
     {%-for prop_name, prop in stinger.properties.items()%}
-    async fn publish_{{prop_name}}_value(mut publisher: MessagePublisher, topic: String, data: {{prop.rust_type}})
+    async fn publish_{{prop_name}}_value(publisher: MqttierClient, topic: String, data: {{prop.rust_type}})
     {
         {%-if prop.arg_list | length == 1%}
         let new_data = {{prop_name | UpperCamelCase}}Property {
             {{prop.arg_list[0].name}}: data,
         };
-        let _pub_result = publisher.publish_retained_structure(topic, &new_data).await;
+        let _pub_result = publisher.publish_state(topic, &new_data, 1).await;
         {%else%}
-        let _pub_result = publisher.publish_retained_structure(topic, &data).await;
+        let _pub_result = publisher.publish_state(topic, &data, 1).await;
         {%endif%}
     }
     {%if not prop.read_only %}
-    async fn update_{{prop_name}}_value(publisher: &mut MessagePublisher, topic: Arc<String>, data: Arc<Mutex<Option<{{prop.rust_type}}>>>, msg: mqtt::Message)
+    async fn update_{{prop_name}}_value(publisher: MqttierClient, topic: Arc<String>, data: Arc<Mutex<Option<{{prop.rust_type}}>>>, msg: ReceivedMessage)
     {
-        let payload_str = msg.payload_str();
+        let payload_str = String::from_utf8_lossy(&msg.payload).to_string();
         let new_data: {{prop_name | UpperCamelCase}}Property = serde_json::from_str(&payload_str).unwrap();
         let mut locked_data = data.lock().unwrap();
         {%-if prop.arg_list | length == 1%}
@@ -216,7 +223,7 @@ impl {{stinger.name | UpperCamelCase}}Server {
         let data2 = new_data;
         {%endif%}
         let _ = tokio::spawn(async move {
-            {{stinger.name | UpperCamelCase}}Server::publish_{{prop_name}}_value(publisher2, topic2, data2).await;
+            {{stinger.rust.server_struct_name}}::publish_{{prop_name}}_value(publisher2, topic2, data2).await;
         });
     }
     {%endif%}{# not read only property #}
@@ -228,11 +235,11 @@ impl {{stinger.name | UpperCamelCase}}Server {
             *locked_data = Some(data.clone());
         }
 
-        let publisher2 = self.msg_publisher.clone();
+        let publisher2 = self.mqttier_client.clone();
         let topic2 = self.properties.{{prop_name}}_topic.as_ref().clone();
         let _ = tokio::spawn(async move {
             println!("Will publish property {{prop_name}} of type {{prop.rust_type}} to {}", topic2);
-            {{stinger.name | UpperCamelCase}}Server::publish_{{prop_name}}_value(publisher2, topic2, data).await;
+            {{stinger.rust.server_struct_name}}::publish_{{prop_name}}_value(publisher2, topic2, data).await;
         });
     }
     {%endfor%}
@@ -242,31 +249,47 @@ impl {{stinger.name | UpperCamelCase}}Server {
     /// Based on the subscription id of the received message, it will call a function to handle the
     /// received message.
     pub async fn receive_loop(&mut self) -> Result<(), JoinError> {
+        // Make sure the MqttierClient is connected and running.
+        let _ = self.mqttier_client.run_loop().await;
 
+        {%if stinger.methods|length > 0 or stinger.properties|length > 0 %}
         // Take ownership of the RX channel that receives MQTT messages.  This will be moved into the loop_task.
         let mut message_receiver = self.msg_streamer_rx.take().expect("msg_streamer_rx should be Some");
+
+        {%if stinger.methods|length > 0 -%}
         let mut method_handlers = self.method_handlers.clone();
+        {%endif-%}
+
         let sub_ids = self.subscription_ids.clone();
-        let mut publisher = self.msg_publisher.clone();
+
+        {%-if stinger.methods|length > 0 %}
+        let publisher = self.mqttier_client.clone();
+        {%endif%}
+
         {%-if stinger.properties | length > 0 %}
         let properties = self.properties.clone();
         {%endif%}
-        let _loop_task = tokio::spawn(async move {
+
+        let loop_task = tokio::spawn(async move {
             while let Some(msg) = message_receiver.recv().await {
                 {%-for method_name, method in stinger.methods.items()%}
                 {%if not loop.first%}else {%endif%}if msg.subscription_id == sub_ids.{{method_name | snake_case}}_method_req {
-                    {{stinger.name | UpperCamelCase}}Server::handle_{{method_name|snake_case}}_request(&mut publisher, &mut method_handlers, msg.message).await;
+                    {{stinger.rust.server_struct_name}}::handle_{{method_name|snake_case}}_request(publisher.clone(), &mut method_handlers, msg).await;
                 }
                 {%-endfor%}{# methods #}
                 {%-for prop_name, prop in stinger.properties.items()%}{%if not prop.read_only %}
                 {%if not loop.first or (stinger.methods | length > 0) %}else {%endif%}if msg.subscription_id == sub_ids.{{prop_name | snake_case}}_property_update {
-                    {{stinger.name | UpperCamelCase}}Server::update_{{prop_name | snake_case}}_value(&mut publisher, properties.{{prop_name | snake_case}}_topic.clone(), properties.{{prop_name | snake_case}}.clone(), msg.message).await;
+                    {{stinger.rust.server_struct_name}}::update_{{prop_name | snake_case}}_value(publisher.clone(), properties.{{prop_name | snake_case}}_topic.clone(), properties.{{prop_name | snake_case}}.clone(), msg).await;
                 }
                 {%-endif%}{%endfor%}{# properties #}
-            }   
+            }
+            println!("No more messages from message_receiver channel");
         });
-
-        println!("Started client receive task");
+        let _ = tokio::join!(loop_task);
+        {%endif%} {# any methods or properties #}
+        
+        println!("Server receive loop completed [error?]");
         Ok(())
     }
+
 }

stingeripc/tools/cli.py

@@ -0,0 +1,73 @@
+
+import os
+from rich import print
+from pathlib import Path
+import typer
+from typing_extensions import Annotated
+from jacobsjinjatoo import templator as jj2
+
+from stingeripc.interface import StingerInterface
+
+from . import markdown_generator
+from . import python_generator
+from . import rust_generator
+
+
+app = typer.Typer(help="stinger-ipc generator CLI")
+
+
+@app.command()
+def generate(
+    language: Annotated[str, typer.Argument(...)],
+    input_file: Annotated[Path, typer.Argument(..., exists=True, file_okay=True, dir_okay=False, readable=True)],
+    output_dir: Annotated[Path, typer.Argument(..., file_okay=False, dir_okay=True, writable=True, readable=True)],
+):
+    """Generate code for a Stinger interface.
+
+    LANGUAGE must be one of: rust, python, markdown
+    INPUT_FILE is the .stinger.yaml file
+    OUTPUT_DIR is the directory that will receive generated files
+    """
+    lang = language.lower()
+    if lang not in ("rust", "python", "markdown", "web"):
+        raise typer.BadParameter("language must be one of: rust, python, markdown, web")
+
+    if lang == "python":
+        # python_generator.main expects Path arguments via typer
+        python_generator.main(input_file, output_dir)
+    elif lang == "markdown":
+        # markdown_generator.main expects Path arguments via typer
+        markdown_generator.main(input_file, output_dir)
+    elif lang == "web":
+        wt = jj2.WebTemplator(output_dir=output_dir)
+        ct = jj2.CodeTemplator(output_dir=output_dir)
+        wt.add_template_dir(
+            os.path.join(os.path.dirname(__file__), "../templates", "html")
+        )
+        ct.add_template_dir(
+            os.path.join(os.path.dirname(__file__), "../templates", "html")
+        )
+        with open(input_file, "r") as f:
+            stinger = StingerInterface.from_yaml(f)
+        for output_file in [
+            "app.js",
+            "styles.css",
+        ]:
+            ct.render_template(f"{output_file}.jinja2", output_file, stinger=stinger)
+        wt.render_template("index.html.jinja2", "index.html", stinger=stinger)
+    else:  # rust
+        rust_generator.main(input_file, output_dir)
+    
+
+    print(f"Generation for '{lang}' completed.")
+
+@app.command()
+def hello():
+    print("Hello world")
+
+def run():
+    app()
+
+if __name__ == "__main__":
+    run()
+

stingeripc/tools/markdown_generator.py

@@ -15,14 +15,16 @@ def main(inname: Annotated[Path, typer.Argument(exists=True, file_okay=True, dir
     params = {
         "stinger": stinger,
     }
-    t = jj2.CodeTemplator(output_dir=os.path.dirname(outdir))
+    output_dir = Path(outdir).resolve()
+    print(f"[bold green]Output directory:[/bold green] {output_dir}")
+    t = jj2.CodeTemplator(output_dir=output_dir)
     t.add_template_dir(
         os.path.join(os.path.dirname(__file__), "../templates", "markdown")
     )
     for output_file in [
         "index.md",
     ]:
-        print(f"[bold red]GENERATING:[/bold red] {output_file}")
+        print(f"[bold red]GENERATING:[/bold red] {os.path.join(outdir, output_file)}")
         t.render_template(f"{output_file}.jinja2", output_file, **params)
 
 def run():

stingeripc/tools/python_generator.py

@@ -1,6 +1,5 @@
 from jacobsjinjatoo import templator as jj2
 from jacobsjinjatoo import stringmanip
-import sys
 import os.path
 import typer
 from typing_extensions import Annotated
@@ -10,25 +9,27 @@ from pathlib import Path
 
 def main(inname: Annotated[Path, typer.Argument(exists=True, file_okay=True, dir_okay=False, readable=True)], outdir: Annotated[Path, typer.Argument(file_okay=False, dir_okay=True, writable=True, readable=True)]):
 
-    print(f"[bold green]Reading:[/bold green] {inname}")
+    print(f"[bold]Reading:[/bold] {inname}")
     with open(inname, "r") as f:
         stinger = StingerInterface.from_yaml(f)
     params = {
         "stinger": stinger,
     }
-    t = jj2.CodeTemplator(output_dir=os.path.dirname(outdir))
+    output_dir = Path(outdir).resolve()
+    print(f"[bold]Output directory:[/bold] {output_dir}")
+    t = jj2.CodeTemplator(output_dir=output_dir)
     t.add_template_dir(
         os.path.join(os.path.dirname(__file__), "../templates", "python")
     )
     for output_file in [
         "pyproject.toml",
     ]:
-        print(f"[bold red]Generating:[/bold red] {output_file}")
-        t.render_template(f"{output_file}.jinja2", os.path.join(outdir, output_file), **params)
+        print(f"[bold green]Generating:[/bold green] {output_file}")
+        t.render_template(f"{output_file}.jinja2", output_file, **params)
 
     package_name = f"{stringmanip.lower_camel_case(stinger.name).lower()}ipc"
-    generated_pkg_dir = os.path.join(outdir, package_name)
-    print(f"[bold red]Making Directory:[/bold red] {generated_pkg_dir}")
+    generated_pkg_dir = output_dir / package_name
+    print(f"[bold]Making Directory:[/bold] {generated_pkg_dir}")
     os.makedirs(generated_pkg_dir, exist_ok=True)
     for output_file in [
         "server.py",
@@ -37,10 +38,11 @@ def main(inname: Annotated[Path, typer.Argument(exists=True, file_okay=True, dir
         "__init__.py",
         "method_codes.py",
     ]:
-        print(f"[bold red]Generating:[/bold red] {output_file}")
-        t.render_template(f"{output_file}.jinja2", os.path.join(generated_pkg_dir, output_file), **params)
+        of = generated_pkg_dir / output_file
+        print(f"[bold green]Generating:[/bold green] {of}")
+        output = t.render_template(f"{output_file}.jinja2", of, **params)
 
-    t.render_template("interface_types.py.jinja2", os.path.join(generated_pkg_dir, f"{stinger.get_enum_module_name()}.py"), **params)
+    t.render_template("interface_types.py.jinja2", f"{generated_pkg_dir}/{stinger.get_enum_module_name()}.py", **params)
 
 def run():
     typer.run(main)

stingeripc/tools/rust_generator.py

@@ -1,50 +1,69 @@
 from jacobsjinjatoo import templator as jj2
-import sys
-import yaml
 import os
 import shutil
+import typer
+from typing_extensions import Annotated
+from pathlib import Path
+from rich import print
 
 from stingeripc import StingerInterface
 
-def main():
-    inname = sys.argv[1] # Path to the stinger file
-    outdir = sys.argv[2] # Directory to which the files should be written
-    with open(inname, "r") as f:
+
+def main(
+    inname: Annotated[Path, typer.Argument(exists=True, file_okay=True, dir_okay=False, readable=True)],
+    outdir: Annotated[Path, typer.Argument(file_okay=False, dir_okay=True, writable=True, readable=True)],
+):
+    """Generate Rust output for a Stinger interface."""
+
+    with inname.open(mode="r") as f:
         stinger = StingerInterface.from_yaml(f)
-    params = {
-        "stinger": stinger,
-    }
 
-    if not os.path.exists(outdir):
+    params = {"stinger": stinger}
+
+    if outdir.is_file():
+        raise RuntimeError("Output directory is a file!")
+
+    if not outdir.is_dir():
         os.makedirs(outdir)
 
-    template_dir = os.path.join(os.path.dirname(__file__), "../templates", "rust")
+    print(f"OUPUT: {outdir}")
 
-    t = jj2.CodeTemplator(output_dir=os.path.dirname(outdir))
+    this_file = Path(__file__)
+    this_dir = this_file.parent
+    template_dir = (this_dir / "../templates" / "rust").resolve()
+
+    t = jj2.CodeTemplator(output_dir=outdir)
     t.add_template_dir(template_dir)
 
     def recursive_render_templates(local_dir: str):
-        cur_template_dir = os.path.join(template_dir, local_dir)
+        local_dir = Path(local_dir)
+        cur_template_dir = template_dir / local_dir
         for entry in os.listdir(cur_template_dir):
-            if entry == 'target':
+            if entry == "target":
                 # Do not copy 'target' dir
                 continue
-            entry_full_path = os.path.join(cur_template_dir, entry)
-            entry_local_path = os.path.join(local_dir, entry)
+            entry_full_path = (cur_template_dir / entry).resolve()
+            entry_local_path = (local_dir / entry)
             if entry.endswith(".jinja2"):
-                print(f"GENER: {entry_local_path}")
-                t.render_template(entry_local_path, entry_local_path[:-len(".jinja2")], **params)
-            elif os.path.isdir(entry_full_path):
-                print(f"MKDIR: {entry_local_path}")
-                new_dir = os.path.join(outdir, entry_local_path)
-                if not os.path.exists(new_dir):
-                    os.makedirs(new_dir)
+                destpath = str(entry_local_path)[:-len(".jinja2")]
+                print(f"GENER: {entry_local_path} -> {destpath}")
+                t.render_template(entry_local_path, destpath, **params)
+            elif entry_full_path.is_dir():
+                new_dir = outdir / entry_local_path
+                print(f"MKDIR: {new_dir.resolve()}")
+                if not new_dir.exists():
+                    new_dir.mkdir(parents=True)
                 recursive_render_templates(entry_local_path)
-            elif os.path.isfile(entry_full_path):
-                shutil.copyfile(entry_full_path, os.path.join(outdir, entry_local_path))
-                print(f"COPY:  {entry_local_path}")
+            elif entry_full_path.is_file():
+                shutil.copyfile(entry_full_path, outdir / entry_local_path)
+                print(f"COPY:  {entry_full_path}")
 
     recursive_render_templates(".")
 
+
+def run():
+    typer.run(main)
+
+
 if __name__ == "__main__":
-    main()
+    run()