Make __str__ return the output of __repr__

Support for `Vec<String>` type

Author: VirxEC

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "rlbot-flatbuffers-py"
-version = "0.4.3"
+version = "0.5.0"
 edition = "2021"
 description = "A Python module implemented in Rust for serializing and deserializing RLBot's flatbuffers"
 repository = "https://github.com/VirxEC/rlbot_flatbuffers_py"

Cargo.toml

@@ -107,6 +107,10 @@ pub fn generator(type_data: &[PythonBindType]) -> io::Result<()> {
                             python_types.push("bytes".to_string());
                             write_fmt!(file, "    {variable_name}: bytes");
                         }
+                        RustType::Vec(InnerVecType::String) => {
+                            python_types.push("Sequence[str]".to_string());
+                            write_fmt!(file, "    {variable_name}: Sequence[str]");
+                        }
                         RustType::Vec(InnerVecType::Custom(inner_type)) => {
                             python_types.push(format!("Sequence[{inner_type}]"));
                             write_fmt!(file, "    {variable_name}: Sequence[{inner_type}]");

codegen/pyi.rs

@@ -4,6 +4,7 @@ use std::{borrow::Cow, fs, iter::repeat, path::Path};
 #[derive(Debug, PartialEq, Eq)]
 pub enum InnerVecType {
     U8,
+    String,
     Custom(String),
 }
 
@@ -157,6 +158,8 @@ impl StructBindGenerator {
                 let (rust_type, inner_type) = if raw_type.starts_with("Vec<") {
                     if raw_type == "Vec<u8>" {
                         (RustType::Vec(InnerVecType::U8), None)
+                    } else if raw_type == "Vec<String>" {
+                        (RustType::Vec(InnerVecType::String), None)
                     } else {
                         let inner_type = raw_type
                             .trim_start_matches("Vec<")
@@ -309,6 +312,7 @@ impl StructBindGenerator {
                 } else {
                     format!("Vec<Py<super::{inner_type}>>")
                 }),
+                RustType::Vec(InnerVecType::String) => Cow::Borrowed("Vec<String>"),
                 RustType::Vec(InnerVecType::U8) => Cow::Borrowed("Py<PyBytes>"),
                 RustType::Box(inner_type) => Cow::Owned(if self.is_frozen {
                     format!("super::{inner_type}")
@@ -375,8 +379,8 @@ impl StructBindGenerator {
     }
 
     fn generate_str_method(&mut self) {
-        write_str!(self, "    pub fn __str__(&self) -> String {");
-        write_str!(self, "        format!(\"{self:?}\")");
+        write_str!(self, "    pub fn __str__(&self, py: Python) -> String {");
+        write_str!(self, "        self.__repr__(py)");
         write_str!(self, "    }");
     }
 
@@ -404,7 +408,7 @@ impl StructBindGenerator {
                 match &variable_info.rust_type {
                     RustType::String => format!("{variable_name}={{:?}}"),
                     RustType::Vec(InnerVecType::U8) => format!("{variable_name}=bytes([{{}}])"),
-                    RustType::Vec(InnerVecType::Custom(_)) => format!("{variable_name}=[{{}}]"),
+                    RustType::Vec(_) => format!("{variable_name}=[{{}}]"),
                     _ => format!("{variable_name}={{}}"),
                 }
             })
@@ -424,6 +428,10 @@ impl StructBindGenerator {
                             write_str!(self, "                .iter()");
                             write_str!(self, "                .map(ToString::to_string)");
                         }
+                        InnerVecType::String => {
+                            write_str!(self, "                .iter()");
+                            write_str!(self, "                .map(|s| format!(\"{s:?}\"))");
+                        }
                         InnerVecType::Custom(_) => {
                             write_str!(self, "                .iter()");
                             write_str!(
@@ -665,6 +673,7 @@ impl Generator for StructBindGenerator {
 
             let variable_type = match &variable_info.rust_type {
                 RustType::Vec(InnerVecType::U8) => String::from("Py<PyBytes>"),
+                RustType::Vec(InnerVecType::String) => String::from("Vec<String>"),
                 RustType::Vec(InnerVecType::Custom(inner_type)) => {
                     if self.is_frozen {
                         format!("Vec<super::{inner_type}>")
@@ -717,7 +726,7 @@ impl Generator for StructBindGenerator {
 
             let end = match &variable_info.rust_type {
                 RustType::Vec(InnerVecType::U8) => Cow::Borrowed("PyBytes::new_bound(py, &[]).unbind()"),
-                RustType::Vec(InnerVecType::Custom(_)) => Cow::Borrowed("Vec::new()"),
+                RustType::Vec(InnerVecType::Custom(_) | InnerVecType::String) => Cow::Borrowed("Vec::new()"),
                 RustType::Option(_, _) => Cow::Borrowed("None"),
                 RustType::Union(inner_type) | RustType::Box(inner_type) | RustType::Custom(inner_type) => {
                     Cow::Owned(format!("super::{inner_type}::py_default(py)"))
@@ -778,6 +787,9 @@ impl Generator for StructBindGenerator {
                         "            {variable_name}: PyBytes::new_bound(py, &flat_t.{variable_name}).unbind(),"
                     )
                 }
+                RustType::Vec(InnerVecType::String) => {
+                    write_fmt!(self, "            {variable_name}: flat_t.{variable_name},")
+                }
                 RustType::Vec(InnerVecType::Custom(_)) => {
                     if self.is_frozen {
                         let map_out = if variable_info.frozen_needs_py {
@@ -895,6 +907,9 @@ impl Generator for StructBindGenerator {
                         "            {variable_name}: py_type.{variable_name}.as_bytes(py).to_vec(),"
                     )
                 }
+                RustType::Vec(InnerVecType::String) => {
+                    write_fmt!(self, "            {variable_name}: py_type.{variable_name}.clone(),")
+                }
                 RustType::Vec(InnerVecType::Custom(_)) => {
                     if self.is_frozen {
                         let map_out = if variable_info.frozen_needs_py {

codegen/structs.rs

@@ -83,8 +83,8 @@ impl UnionBindGenerator {
     }
 
     fn generate_str_method(&mut self) {
-        write_str!(self, "    pub fn __str__(&self) -> String {");
-        write_str!(self, "        format!(\"{self:?}\")");
+        write_str!(self, "    pub fn __str__(&self, py: Python) -> String {");
+        write_str!(self, "        self.__repr__(py)");
         write_str!(self, "    }");
     }