rlbot-flatbuffers 0.14.5__tar.gz → 0.14.6__tar.gz

{rlbot_flatbuffers-0.14.5 → rlbot_flatbuffers-0.14.6}/Cargo.lock

@@ -115,9 +115,9 @@ checksum = "71dd52191aae121e8611f1e8dc3e324dd0dd1dee1e6dd91d10ee07a3cfb4d9d8"
 
 [[package]]
 name = "libc"
-version = "0.2.170"
+version = "0.2.171"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "875b3680cb2f8f71bdcf9a30f38d48282f5d3c95cbf9b3fa57269bb5d5c06828"
+checksum = "c19937216e9d3aa9956d9bb8dfc0b0c8beb6058fc4f7a4dc4d850edf86a237d6"
 
 [[package]]
 name = "manyhow"
@@ -153,9 +153,9 @@ dependencies = [
 
 [[package]]
 name = "once_cell"
-version = "1.20.3"
+version = "1.21.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "945462a4b81e43c4e3ba96bd7b49d834c6f61198356aa858733bc4acf3cbe62e"
+checksum = "d75b0bedcc4fe52caa0e03d9f1151a323e4aa5e2d78ba3580400cd3c9e2bc4bc"
 
 [[package]]
 name = "portable-atomic"
@@ -248,9 +248,9 @@ dependencies = [
 
 [[package]]
 name = "quote"
-version = "1.0.39"
+version = "1.0.40"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c1f1914ce909e1658d9907913b4b91947430c7d9be598b15a1912935b8c04801"
+checksum = "1885c039570dc00dcb4ff087a89e185fd56bae234ddc7f056a945bf36467248d"
 dependencies = [
  "proc-macro2",
 ]
@@ -279,7 +279,7 @@ dependencies = [
 
 [[package]]
 name = "rlbot_flatbuffers"
-version = "0.14.5"
+version = "0.14.6"
 dependencies = [
  "flatbuffers",
  "get-size",

{rlbot_flatbuffers-0.14.5 → rlbot_flatbuffers-0.14.6}/Cargo.toml

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

{rlbot_flatbuffers-0.14.5 → rlbot_flatbuffers-0.14.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rlbot_flatbuffers
-Version: 0.14.5
+Version: 0.14.6
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy

{rlbot_flatbuffers-0.14.5 → rlbot_flatbuffers-0.14.6}/codegen/enums.rs

@@ -16,10 +16,7 @@ fn camel_to_snake_case(variable_name: &str) -> String {
     for c in variable_name.chars() {
         if c.is_uppercase() {
             if last_was_uppercase {
-                snake_case_parts
-                    .last_mut()
-                    .unwrap()
-                    .push(c.to_lowercase().next().unwrap());
+                snake_case_parts.last_mut().unwrap().push(c.to_lowercase().next().unwrap());
             } else {
                 snake_case_parts.push(c.to_lowercase().to_string());
             }
@@ -80,9 +77,7 @@ impl EnumBindGenerator {
         })
     }
 
-    pub fn raw_types_to_custom(
-        raw_types: Vec<(&str, &str, Option<Vec<String>>)>,
-    ) -> Vec<CustomEnumType> {
+    pub fn raw_types_to_custom(raw_types: Vec<(&str, &str, Option<Vec<String>>)>) -> Vec<CustomEnumType> {
         raw_types
             .into_iter()
             .map(|(name, raw_type, doc_str)| CustomEnumType {
@@ -129,17 +124,12 @@ impl EnumBindGenerator {
                 continue;
             }
 
-            let definition = line_trim
-                .trim_start_matches("pub const ")
-                .trim_end_matches(';');
+            let definition = line_trim.trim_start_matches("pub const ").trim_end_matches(';');
 
             let mut parts = definition.split(": Self = ");
 
             let variable_name = parts.next()?;
-            let variable_value = parts
-                .next()?
-                .trim_start_matches("Self(")
-                .trim_end_matches(')');
+            let variable_value = parts.next()?.trim_start_matches("Self(").trim_end_matches(')');
 
             let docs = if docs.is_empty() {
                 None
@@ -169,14 +159,11 @@ impl EnumBindGenerator {
         let union_end_definition = "}\n";
         let union_end = contents[union_start..].find(union_end_definition).unwrap();
 
-        let union_definition = &contents[union_start + union_definition.len()
-            ..union_start + union_end - union_end_definition.len()];
+        let union_definition =
+            &contents[union_start + union_definition.len()..union_start + union_end - union_end_definition.len()];
 
         for (line, variable) in union_definition.split('\n').zip(&mut custom_types) {
-            let line_trim = line
-                .trim()
-                .trim_start_matches(&variable.name)
-                .trim_end_matches(',');
+            let line_trim = line.trim().trim_start_matches(&variable.name).trim_end_matches(',');
 
             if line_trim.is_empty() {
                 variable.value = None;
@@ -185,9 +172,7 @@ impl EnumBindGenerator {
 
             variable.snake_case_name = camel_to_snake_case(variable.name.as_str());
 
-            let new_type = line_trim
-                .trim_start_matches("(Box<")
-                .trim_end_matches("T>)");
+            let new_type = line_trim.trim_start_matches("(Box<").trim_end_matches("T>)");
             variable.value = Some(new_type.to_string());
         }
 
@@ -204,11 +189,7 @@ impl EnumBindGenerator {
 
         for variable_info in &self.types {
             let variable_name = variable_info.name.as_str();
-            write_fmt!(
-                self,
-                "            {} => Ok(Self::{variable_name}),",
-                variable_info.raw_type
-            );
+            write_fmt!(self, "            {} => Ok(Self::{variable_name}),", variable_info.raw_type);
         }
 
         if self.types.len() != usize::from(u8::MAX) {
@@ -256,10 +237,7 @@ impl Generator for EnumBindGenerator {
             contents = contents.replace("\r\n", "\n");
         }
 
-        contents = contents.replace(
-            "use self::flatbuffers",
-            "use get_size::GetSize;\nuse self::flatbuffers",
-        );
+        contents = contents.replace("use self::flatbuffers", "use get_size::GetSize;\nuse self::flatbuffers");
 
         contents = contents.replace(
             "#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]\n",
@@ -288,14 +266,8 @@ impl Generator for EnumBindGenerator {
 
     fn generate_definition(&mut self) {
         write_str!(self, "#[allow(non_camel_case_types)]");
-        write_str!(
-            self,
-            "#[pyclass(module = \"rlbot_flatbuffers\", frozen, hash, eq, eq_int)]"
-        );
-        write_str!(
-            self,
-            "#[derive(Debug, Default, Clone, Copy, PartialEq, Eq, Hash)]"
-        );
+        write_str!(self, "#[pyclass(module = \"rlbot_flatbuffers\", frozen, hash, eq, eq_int)]");
+        write_str!(self, "#[derive(Debug, Default, Clone, Copy, PartialEq, Eq, Hash)]");
         write_fmt!(self, "pub enum {} {{", self.struct_name);
         write_str!(self, "    #[default]");
 
@@ -309,17 +281,8 @@ impl Generator for EnumBindGenerator {
     }
 
     fn generate_from_flat_impls(&mut self) {
-        write_fmt!(
-            self,
-            "impl From<flat::{}> for {} {{",
-            self.struct_name,
-            self.struct_name
-        );
-        write_fmt!(
-            self,
-            "    fn from(flat_t: flat::{}) -> Self {{",
-            self.struct_name
-        );
+        write_fmt!(self, "impl From<flat::{}> for {} {{", self.struct_name, self.struct_name);
+        write_fmt!(self, "    fn from(flat_t: flat::{}) -> Self {{", self.struct_name);
         write_str!(self, "        match flat_t {");
 
         for variable_info in &self.types {
@@ -332,11 +295,7 @@ impl Generator for EnumBindGenerator {
             );
         }
 
-        write_fmt!(
-            self,
-            "            _ => Self::{},",
-            self.types.last().unwrap().name.as_str()
-        );
+        write_fmt!(self, "            _ => Self::{},", self.types.last().unwrap().name.as_str());
 
         write_str!(self, "        }");
         write_str!(self, "    }");
@@ -345,17 +304,8 @@ impl Generator for EnumBindGenerator {
     }
 
     fn generate_to_flat_impls(&mut self) {
-        write_fmt!(
-            self,
-            "impl From<&{}> for flat::{} {{",
-            self.struct_name,
-            self.struct_name
-        );
-        write_fmt!(
-            self,
-            "    fn from(py_type: &{}) -> Self {{",
-            self.struct_name
-        );
+        write_fmt!(self, "impl From<&{}> for flat::{} {{", self.struct_name, self.struct_name);
+        write_fmt!(self, "    fn from(py_type: &{}) -> Self {{", self.struct_name);
         write_str!(self, "        match *py_type {");
 
         for variable_info in &self.types {

{rlbot_flatbuffers-0.14.5 → rlbot_flatbuffers-0.14.6}/codegen/main.rs

@@ -53,15 +53,10 @@ impl PythonBindType {
         "PredictionSlice",
         "BallPrediction",
     ];
-    pub const UNIONS: [&'static str; 4] = [
-        "PlayerClass",
-        "CollisionShape",
-        "RelativeAnchor",
-        "RenderType",
-    ];
+    pub const UNIONS: [&'static str; 4] = ["PlayerClass", "CollisionShape", "RelativeAnchor", "RenderType"];
 
-    pub const DEFAULT_OVERRIDES: [(&'static str, &'static str, &'static str); 1] =
-        [("Color", "a", "255")];
+    pub const OPTIONAL_UNIONS: [&'static str; 1] = ["RelativeAnchor"];
+    pub const DEFAULT_OVERRIDES: [(&'static str, &'static str, &'static str); 1] = [("Color", "a", "255")];
     pub const FREELIST_TYPES: [(&'static str, usize); 0] = [];
 
     fn new(path: &Path) -> Option<Self> {
@@ -106,12 +101,7 @@ impl PythonBindType {
         let struct_doc_str = if docs.is_empty() {
             None
         } else {
-            Some(
-                docs.into_iter()
-                    .map(|s| s.to_string())
-                    .rev()
-                    .collect::<Vec<_>>(),
-            )
+            Some(docs.into_iter().map(|s| s.to_string()).rev().collect::<Vec<_>>())
         };
 
         if let Some(types) = StructBindGenerator::get_types(&contents, &struct_t_name) {
@@ -125,15 +115,11 @@ impl PythonBindType {
             )?));
         }
 
-        if let Some((types, enum_type)) =
-            enums::EnumBindGenerator::get_types(&contents, &struct_name)
-        {
+        if let Some((types, enum_type)) = enums::EnumBindGenerator::get_types(&contents, &struct_name) {
             return Some(match enum_type {
-                enums::EnumType::Enum => Self::Enum(enums::EnumBindGenerator::new(
-                    filename.to_string(),
-                    struct_name,
-                    types,
-                )?),
+                enums::EnumType::Enum => {
+                    Self::Enum(enums::EnumBindGenerator::new(filename.to_string(), struct_name, types)?)
+                }
                 enums::EnumType::Union => Self::Union(unions::UnionBindGenerator::new(
                     filename.to_string(),
                     struct_name,
@@ -183,10 +169,7 @@ fn mod_rs_generator(type_data: &[PythonBindType]) -> io::Result<()> {
 
     file_contents.push(Cow::Borrowed(""));
 
-    fs::write(
-        format!("{PYTHON_OUT_FOLDER}/mod.rs"),
-        file_contents.join("\n"),
-    )?;
+    fs::write(format!("{PYTHON_OUT_FOLDER}/mod.rs"), file_contents.join("\n"))?;
 
     Ok(())
 }
@@ -204,10 +187,7 @@ fn run_flatc() -> io::Result<()> {
     let mut schema_folder = Path::new(SCHEMA_FOLDER);
     if !schema_folder.exists() {
         schema_folder = Path::new(SCHEMA_FOLDER_BACKUP);
-        assert!(
-            schema_folder.exists(),
-            "Could not find flatbuffers schema folder"
-        );
+        assert!(schema_folder.exists(), "Could not find flatbuffers schema folder");
     }
 
     let schema_folder_str = schema_folder.display();

{rlbot_flatbuffers-0.14.5 → rlbot_flatbuffers-0.14.6}/codegen/pyi.rs

@@ -93,16 +93,10 @@ pub fn generator(type_data: &[PythonBindType]) -> io::Result<()> {
                 write_str!(file, "    def __new__(cls, value: int = 0): ...");
                 write_str!(file, "    def __init__(self, value: int = 0):");
                 write_str!(file, "        \"\"\"");
-                write_str!(
-                    file,
-                    "        :raises ValueError: If the `value` is not a valid enum value"
-                );
+                write_str!(file, "        :raises ValueError: If the `value` is not a valid enum value");
                 write_str!(file, "        \"\"\"");
                 write_str!(file, "    def __int__(self) -> int: ...");
-                write_fmt!(
-                    file,
-                    "    def __eq__(self, other: {type_name}) -> bool: ..."
-                );
+                write_fmt!(file, "    def __eq__(self, other: {type_name}) -> bool: ...");
                 write_str!(file, "    def __hash__(self) -> str: ...");
             }
             PythonBindType::Struct(bind) => {
@@ -208,32 +202,32 @@ pub fn generator(type_data: &[PythonBindType]) -> io::Result<()> {
                             python_types.push("str".to_string());
                             write_fmt!(file, "    {variable_name}: str");
                         }
-                        RustType::Union(type_name) => {
-                            write_fmt!(file, "    {variable_name}: {type_name}");
+                        RustType::Union(type_name, is_optional) => {
+                            if *is_optional {
+                                write_fmt!(file, "    {variable_name}: Optional[{type_name}]");
+                            } else {
+                                write_fmt!(file, "    {variable_name}: {type_name}");
+                            }
 
                             // search for the union with the name `type_name` and get the types
                             let union_types = type_data
                                 .iter()
                                 .find_map(|item| match item {
-                                    PythonBindType::Union(bind)
-                                        if bind.struct_name() == type_name =>
-                                    {
-                                        Some(
-                                            bind.types
-                                                .iter()
-                                                .skip(1)
-                                                .map(|v| v.name.as_str())
-                                                .collect::<Vec<_>>(),
-                                        )
+                                    PythonBindType::Union(bind) if bind.struct_name() == type_name => {
+                                        Some(bind.types.iter().skip(1).map(|v| v.name.as_str()).collect::<Vec<_>>())
                                     }
                                     _ => None,
                                 })
                                 .unwrap();
-                            python_types.push(union_types.join(" | "));
+
+                            let python_type = union_types.join(" | ");
+                            python_types.push(if *is_optional {
+                                format!("Optional[{python_type}]")
+                            } else {
+                                python_type
+                            });
                         }
-                        RustType::Custom(type_name)
-                        | RustType::Other(type_name)
-                        | RustType::Base(type_name) => {
+                        RustType::Custom(type_name) | RustType::Other(type_name) | RustType::Base(type_name) => {
                             python_types.push(type_name.to_string());
                             write_fmt!(file, "    {variable_name}: {type_name}");
                         }
@@ -276,10 +270,7 @@ pub fn generator(type_data: &[PythonBindType]) -> io::Result<()> {
 
                             if let Some((field, value)) = bind.default_override {
                                 if field == variable_name {
-                                    write_fmt!(
-                                        file,
-                                        "        {variable_name}: {python_type} = {value},"
-                                    );
+                                    write_fmt!(file, "        {variable_name}: {python_type} = {value},");
                                     continue;
                                 }
                             }
@@ -290,19 +281,15 @@ pub fn generator(type_data: &[PythonBindType]) -> io::Result<()> {
                                 "String" => Cow::Borrowed("\"\""),
                                 "Vec<u8>" => Cow::Borrowed("b\"\""),
                                 t => {
-                                    if python_type.starts_with("Optional")
-                                        || t.starts_with("Option<")
-                                    {
+                                    if python_type.starts_with("Optional") || t.starts_with("Option<") {
                                         Cow::Borrowed("None")
                                     } else if let Some(pos) = python_type.find('|') {
                                         Cow::Owned(format!("{}()", &python_type[..pos - 1]))
                                     } else if t.starts_with("Vec<") {
                                         Cow::Borrowed("[]")
                                     } else if t.starts_with("Box<") {
-                                        let inner_type = t
-                                            .trim_start_matches("Box<")
-                                            .trim_end_matches('>')
-                                            .trim_end_matches('T');
+                                        let inner_type =
+                                            t.trim_start_matches("Box<").trim_end_matches('>').trim_end_matches('T');
                                         Cow::Owned(format!("{inner_type}()"))
                                     } else {
                                         Cow::Owned(format!("{}()", t.trim_end_matches('T')))
@@ -310,10 +297,7 @@ pub fn generator(type_data: &[PythonBindType]) -> io::Result<()> {
                                 }
                             };
 
-                            write_fmt!(
-                                file,
-                                "        {variable_name}: {python_type} = {default_value},"
-                            );
+                            write_fmt!(file, "        {variable_name}: {python_type} = {default_value},");
                         }
 
                         write_str!(file, "    ): ...");

{rlbot_flatbuffers-0.14.5 → rlbot_flatbuffers-0.14.6}/codegen/structs.rs

@@ -23,7 +23,7 @@ pub enum RustType {
     String,
     Box(String),
     Option(InnerOptionType, String),
-    Union(String),
+    Union(String, bool),
     Custom(String),
     Base(String),
     Other(String),
@@ -82,8 +82,7 @@ impl StructBindGenerator {
         let is_frozen = PythonBindType::FROZEN_TYPES.contains(&struct_name.as_str());
         let is_no_set = PythonBindType::NO_SET_TYPES.contains(&struct_name.as_str());
 
-        let has_complex_pack =
-            contents.contains("pub fn pack<'b, A: flatbuffers::Allocator + 'b>(");
+        let has_complex_pack = contents.contains("pub fn pack<'b, A: flatbuffers::Allocator + 'b>(");
 
         let mut file_contents = vec![];
 
@@ -105,26 +104,17 @@ impl StructBindGenerator {
         file_contents.push(Cow::Borrowed("use pyo3::{prelude::*, types::*};"));
         file_contents.push(Cow::Borrowed(""));
 
-        let default_override =
-            PythonBindType::DEFAULT_OVERRIDES
-                .iter()
-                .find_map(|&(name, field, value)| {
-                    if name == struct_name.as_str() {
-                        Some((field, value))
-                    } else {
-                        None
-                    }
-                });
+        let default_override = PythonBindType::DEFAULT_OVERRIDES.iter().find_map(|&(name, field, value)| {
+            if name == struct_name.as_str() {
+                Some((field, value))
+            } else {
+                None
+            }
+        });
 
         let freelist_size = PythonBindType::FREELIST_TYPES
             .iter()
-            .find_map(|&(name, size)| {
-                if name == struct_name.as_str() {
-                    Some(size)
-                } else {
-                    None
-                }
-            })
+            .find_map(|&(name, size)| if name == struct_name.as_str() { Some(size) } else { None })
             .unwrap_or_default();
 
         Some(Self {
@@ -148,9 +138,7 @@ impl StructBindGenerator {
         let struct_start = contents.find(&struct_start_definition)?;
 
         let struct_end_definition = "}\n";
-        let struct_end = contents[struct_start..]
-            .find(struct_end_definition)
-            .unwrap();
+        let struct_end = contents[struct_start..].find(struct_end_definition).unwrap();
 
         let start = struct_start + struct_start_definition.len();
         let end = struct_start + struct_end - struct_end_definition.len();
@@ -187,12 +175,7 @@ impl StructBindGenerator {
                 let struct_doc_str = if docs.is_empty() {
                     None
                 } else {
-                    Some(
-                        docs.into_iter()
-                            .map(|s| s.to_string())
-                            .rev()
-                            .collect::<Vec<_>>(),
-                    )
+                    Some(docs.into_iter().map(|s| s.to_string()).rev().collect::<Vec<_>>())
                 };
 
                 Some((name, raw_type, struct_doc_str))
@@ -232,30 +215,18 @@ impl StructBindGenerator {
                     let inner = raw_type.trim_start_matches("Option<").trim_end_matches('>');
 
                     if inner.starts_with("Box<") {
-                        let inner_type = inner
-                            .trim_start_matches("Box<")
-                            .trim_end_matches('>')
-                            .trim_end_matches('T');
+                        let inner_type = inner.trim_start_matches("Box<").trim_end_matches('>').trim_end_matches('T');
                         (
                             RustType::Option(InnerOptionType::Box, inner_type.to_string()),
                             Some(inner_type),
                         )
                     } else if inner == "String" {
-                        (
-                            RustType::Option(InnerOptionType::String, inner.to_string()),
-                            None,
-                        )
+                        (RustType::Option(InnerOptionType::String, inner.to_string()), None)
                     } else if PythonBindType::BASE_TYPES.contains(&inner) {
-                        (
-                            RustType::Option(InnerOptionType::BaseType, inner.to_string()),
-                            None,
-                        )
+                        (RustType::Option(InnerOptionType::BaseType, inner.to_string()), None)
                     } else {
                         let inner = inner.trim_end_matches('T');
-                        (
-                            RustType::Option(InnerOptionType::Custom, inner.to_string()),
-                            Some(inner),
-                        )
+                        (RustType::Option(InnerOptionType::Custom, inner.to_string()), Some(inner))
                     }
                 } else if raw_type == "String" {
                     (RustType::String, None)
@@ -269,7 +240,10 @@ impl StructBindGenerator {
                     let inner_type = raw_type.trim_end_matches('T');
 
                     if PythonBindType::UNIONS.contains(&inner_type) {
-                        (RustType::Union(inner_type.to_string()), Some(inner_type))
+                        (
+                            RustType::Union(inner_type.to_string(), PythonBindType::OPTIONAL_UNIONS.contains(&inner_type)),
+                            Some(inner_type),
+                        )
                     } else {
                         (RustType::Custom(inner_type.to_string()), Some(inner_type))
                     }
@@ -338,7 +312,7 @@ impl StructBindGenerator {
 
                     format!("{variable_name}=None")
                 }
-                RustType::Union(_)
+                RustType::Union(_, _)
                 | RustType::Box(_)
                 | RustType::Custom(_)
                 | RustType::Vec(InnerVecType::U8)
@@ -367,11 +341,7 @@ impl StructBindGenerator {
             write_str!(self, "    #[allow(clippy::too_many_arguments)]");
         }
 
-        write_fmt!(
-            self,
-            "    #[pyo3(signature = ({}))]",
-            signature_parts.join(", ")
-        );
+        write_fmt!(self, "    #[pyo3(signature = ({}))]", signature_parts.join(", "));
         write_str!(self, "    pub fn new(");
 
         if needs_python {
@@ -383,18 +353,12 @@ impl StructBindGenerator {
 
             let variable_type = match &variable_info.rust_type {
                 RustType::Vec(InnerVecType::Custom(_)) => Cow::Borrowed("Option<Py<PyList>>"),
-                RustType::Vec(InnerVecType::Base(inner_type)) => {
-                    Cow::Owned(format!("Vec<{}>", inner_type))
-                }
+                RustType::Vec(InnerVecType::Base(inner_type)) => Cow::Owned(format!("Vec<{}>", inner_type)),
                 RustType::Vec(InnerVecType::String) => Cow::Borrowed("Vec<String>"),
                 RustType::Vec(InnerVecType::U8) => Cow::Borrowed("Option<Py<PyBytes>>"),
                 RustType::Box(inner_type) => Cow::Owned(format!("Option<Py<super::{inner_type}>>")),
-                RustType::Option(InnerOptionType::BaseType, inner_type) => {
-                    Cow::Owned(format!("Option<{inner_type}>"))
-                }
-                RustType::Option(InnerOptionType::String, _) => {
-                    Cow::Borrowed("Option<Py<PyString>>")
-                }
+                RustType::Option(InnerOptionType::BaseType, inner_type) => Cow::Owned(format!("Option<{inner_type}>")),
+                RustType::Option(InnerOptionType::String, _) => Cow::Borrowed("Option<Py<PyString>>"),
                 RustType::Option(_, inner_type) => {
                     if inner_type == "Float" {
                         Cow::Borrowed("Option<crate::PartFloats>")
@@ -409,12 +373,8 @@ impl StructBindGenerator {
                     item => item,
                 }),
                 RustType::String => Cow::Borrowed("Option<Py<PyString>>"),
-                RustType::Union(inner_type) => {
-                    Cow::Owned(format!("Option<super::{inner_type}Union>"))
-                }
-                RustType::Custom(inner_type) => {
-                    Cow::Owned(format!("Option<Py<super::{inner_type}>>"))
-                }
+                RustType::Union(inner_type, _) => Cow::Owned(format!("Option<super::{inner_type}Union>")),
+                RustType::Custom(inner_type) => Cow::Owned(format!("Option<Py<super::{inner_type}>>")),
                 RustType::Other(inner_type) => Cow::Owned(format!("super::{inner_type}")),
             };
 
@@ -428,18 +388,21 @@ impl StructBindGenerator {
             let variable_name = variable_info.name.as_str();
 
             if variable_info.is_special_base.is_some() {
-                write_fmt!(
-                    self,
-                    "            {variable_name}: {variable_name}.map(|x| x.into_gil(py)),"
-                );
+                write_fmt!(self, "            {variable_name}: {variable_name}.map(|x| x.into_gil(py)),");
                 continue;
             }
 
             match &variable_info.rust_type {
-                RustType::Union(inner_type) => {
+                RustType::Union(inner_type, is_optional) => {
+                    let end = if *is_optional {
+                        Cow::Borrowed("")
+                    } else {
+                        Cow::Owned(format!(".unwrap_or_else(|| super::{inner_type}::py_default(py))"))
+                    };
+
                     write_fmt!(
                         self,
-                        "            {variable_name}: {variable_name}.map(|u| Py::new(py, super::{inner_type}::new(u)).unwrap()).unwrap_or_else(|| super::{inner_type}::py_default(py)),"
+                        "            {variable_name}: {variable_name}.map(|u| Py::new(py, super::{inner_type}::new(u)).unwrap()){end},"
                     );
                 }
                 RustType::Box(inner_type) | RustType::Custom(inner_type) => {
@@ -491,14 +454,8 @@ impl StructBindGenerator {
                 RustType::Base(inner_type) => match inner_type.as_str() {
                     "f32" => {
                         write_str!(self, "\n    #[setter]");
-                        write_fmt!(
-                            self,
-                            "    pub fn {variable_name}(&mut self, py: Python, value: f64) {{",
-                        );
-                        write_fmt!(
-                            self,
-                            "        self.{variable_name} = PyFloat::new(py, value).unbind();"
-                        );
+                        write_fmt!(self, "    pub fn {variable_name}(&mut self, py: Python, value: f64) {{",);
+                        write_fmt!(self, "        self.{variable_name} = PyFloat::new(py, value).unbind();");
                         write_str!(self, "    }");
                     }
                     _ => continue,
@@ -541,11 +498,7 @@ impl StructBindGenerator {
             })
             .collect::<Vec<_>>()
             .join(", ");
-        write_fmt!(
-            self,
-            "            \"{}({repr_signature})\",",
-            self.struct_name
-        );
+        write_fmt!(self, "            \"{}({repr_signature})\",", self.struct_name);
 
         for variable_info in &self.types {
             let variable_name = variable_info.name.as_str();
@@ -582,51 +535,46 @@ impl StructBindGenerator {
                 RustType::Option(inner_type, _) => {
                     write_fmt!(self, "            self.{variable_name}");
                     write_str!(self, "                .as_ref()");
+                    write_str!(self, "                .map_or_else(crate::none_str, |i| {");
 
                     match inner_type {
                         InnerOptionType::BaseType => {
-                            write_str!(self, "                .map(|i| format!(\"{i:?}\"))");
+                            write_str!(self, "                    format!(\"{i:?}\")");
                         }
                         InnerOptionType::String => {
                             write_str!(
                                 self,
-                                "                .map(|i| format!(\"{:?}\", i.to_str(py).unwrap().to_string()))"
+                                "                    format!(\"{:?}\", i.to_str(py).unwrap().to_string())"
                             );
                         }
                         _ => {
-                            write_str!(self, "                .map(|x| x.borrow(py).__repr__(py))");
+                            write_str!(self, "                    i.borrow(py).__repr__(py)");
                         }
                     }
 
-                    write_str!(self, "                .unwrap_or_else(crate::none_str),");
+                    write_str!(self, "                }),");
                 }
-                RustType::Union(_) => {
-                    write_fmt!(
-                        self,
-                        "            self.{variable_name}.borrow(py).inner_repr(py),"
-                    );
+                RustType::Union(_, is_optional) => {
+                    if *is_optional {
+                        write_fmt!(self, "            self.{variable_name}");
+                        write_str!(self, "                .as_ref()");
+                        write_str!(self, "                .map_or_else(crate::none_str, |i| i.borrow(py).inner_repr(py)),");
+                    } else {
+                        write_fmt!(self, "            self.{variable_name}.borrow(py).inner_repr(py),");
+                    }
                 }
                 RustType::Box(_) | RustType::Custom(_) => {
-                    write_fmt!(
-                        self,
-                        "            self.{variable_name}.borrow(py).__repr__(py),"
-                    );
+                    write_fmt!(self, "            self.{variable_name}.borrow(py).__repr__(py),");
                 }
                 RustType::Base(inner_type) => {
                     if inner_type == "bool" {
-                        write_fmt!(
-                            self,
-                            "            crate::bool_to_str(self.{variable_name}),"
-                        );
+                        write_fmt!(self, "            crate::bool_to_str(self.{variable_name}),");
                     } else {
                         write_fmt!(self, "            self.{variable_name},");
                     }
                 }
                 RustType::String => {
-                    write_fmt!(
-                        self,
-                        "            self.{variable_name}.bind(py).to_cow().unwrap(),"
-                    );
+                    write_fmt!(self, "            self.{variable_name}.bind(py).to_cow().unwrap(),");
                 }
                 RustType::Other(_) => {
                     write_fmt!(self, "            self.{variable_name}.__repr__(),");
@@ -640,10 +588,7 @@ impl StructBindGenerator {
 
     fn generate_long_args(&mut self) {
         write_str!(self, "    #[classattr]");
-        write_str!(
-            self,
-            "    fn __match_args__(py: Python) -> Bound<pyo3::types::PyTuple> {"
-        );
+        write_str!(self, "    fn __match_args__(py: Python) -> Bound<pyo3::types::PyTuple> {");
         write_str!(self, "        pyo3::types::PyTuple::new(py, [");
 
         for variable_info in &self.types {
@@ -653,10 +598,7 @@ impl StructBindGenerator {
         write_str!(self, "        ]).unwrap()");
         write_str!(self, "    }\n");
         write_str!(self, "    #[classattr]");
-        write_str!(
-            self,
-            "    fn __slots__(py: Python) -> Bound<pyo3::types::PyTuple> {"
-        );
+        write_str!(self, "    fn __slots__(py: Python) -> Bound<pyo3::types::PyTuple> {");
         write_str!(self, "        Self::__match_args__(py)");
         write_str!(self, "    }\n");
     }
@@ -691,10 +633,7 @@ impl StructBindGenerator {
     }
 
     fn generate_pack_method(&mut self) {
-        write_str!(
-            self,
-            "    fn pack<'py>(&self, py: Python<'py>) -> Bound<'py, PyBytes> {"
-        );
+        write_str!(self, "    fn pack<'py>(&self, py: Python<'py>) -> Bound<'py, PyBytes> {");
         write_fmt!(
             self,
             "        let flat_t = flat::{}::from_gil(py, self);",
@@ -702,15 +641,9 @@ impl StructBindGenerator {
         );
 
         if self.has_complex_pack {
-            write_str!(
-                self,
-                "        let size = flat_t.get_size().next_power_of_two();"
-            );
+            write_str!(self, "        let size = flat_t.get_size().next_power_of_two();");
             write_str!(self, "");
-            write_str!(
-                self,
-                "        let mut builder = FlatBufferBuilder::with_capacity(size);"
-            );
+            write_str!(self, "        let mut builder = FlatBufferBuilder::with_capacity(size);");
             write_str!(self, "        let offset = flat_t.pack(&mut builder);");
             write_str!(self, "        builder.finish(offset, None);");
             write_str!(self, "");
@@ -806,17 +739,31 @@ impl StructBindGenerator {
                         "        self.{variable_name}.bind_borrowed(py).borrow_mut().unpack_from(py, flat_t.{variable_name});"
                     )
                 }
-                RustType::Union(_) => {
+                RustType::Union(inner_type, true) => {
+                    write_fmt!(self, "        match flat_t.{variable_name} {{");
+                    write_fmt!(self, "            flat::{inner_type}T::NONE => self.{variable_name} = None,");
+                    write_str!(self, "            x => {");
+                    write_fmt!(self, "                match &mut self.{variable_name} {{");
+                    write_str!(
+                        self,
+                        "                    Some(item) => item.bind_borrowed(py).borrow_mut().unpack_from(py, x),"
+                    );
+                    write_fmt!(
+                        self,
+                        "                    None => self.{variable_name} = Some(crate::into_py_from(py, x)),"
+                    );
+                    write_str!(self, "                }");
+                    write_str!(self, "            }");
+                    write_str!(self, "        }");
+                }
+                RustType::Union(_, false) => {
                     let conv_str = if variable_info.is_frozen {
                         " = crate::into_py_from"
                     } else {
                         ".bind_borrowed(py).borrow_mut().unpack_from"
                     };
 
-                    write_fmt!(
-                        self,
-                        "        self.{variable_name}{conv_str}(py, flat_t.{variable_name});"
-                    );
+                    write_fmt!(self, "        self.{variable_name}{conv_str}(py, flat_t.{variable_name});");
                 }
                 RustType::String => {
                     write_fmt!(
@@ -832,22 +779,13 @@ impl StructBindGenerator {
                         );
                     }
                     _ => {
-                        write_fmt!(
-                            self,
-                            "        self.{variable_name} = flat_t.{variable_name};"
-                        );
+                        write_fmt!(self, "        self.{variable_name} = flat_t.{variable_name};");
                     }
                 },
                 RustType::Other(_) => {
-                    write_fmt!(
-                        self,
-                        "        self.{variable_name} = flat_t.{variable_name}.into();",
-                    );
+                    write_fmt!(self, "        self.{variable_name} = flat_t.{variable_name}.into();",);
                 }
-                _ => write_fmt!(
-                    self,
-                    "        self.{variable_name} = flat_t.{variable_name};"
-                ),
+                _ => write_fmt!(self, "        self.{variable_name} = flat_t.{variable_name};"),
             }
         }
 
@@ -860,16 +798,9 @@ impl StructBindGenerator {
             self,
             "    fn unpack_with(&mut self, py: Python, data: &[u8]) -> PyResult<()> {{"
         );
-        write_fmt!(
-            self,
-            "        match root::<flat::{}>(data) {{",
-            self.struct_name
-        );
+        write_fmt!(self, "        match root::<flat::{}>(data) {{", self.struct_name);
         write_str!(self, "            Ok(flat_t) => {");
-        write_str!(
-            self,
-            "                self.unpack_from(py, flat_t.unpack());"
-        );
+        write_str!(self, "                self.unpack_from(py, flat_t.unpack());");
         write_str!(self, "                Ok(())");
         write_str!(self, "            }");
         write_str!(self, "            Err(e) => Err(flat_err_to_py(e)),");
@@ -879,15 +810,8 @@ impl StructBindGenerator {
 
     fn generate_unpack_method(&mut self) {
         write_str!(self, "    #[staticmethod]");
-        write_str!(
-            self,
-            "    fn unpack(py: Python, data: &[u8]) -> PyResult<Py<Self>> {"
-        );
-        write_fmt!(
-            self,
-            "        match root::<flat::{}>(data) {{",
-            self.struct_name
-        );
+        write_str!(self, "    fn unpack(py: Python, data: &[u8]) -> PyResult<Py<Self>> {");
+        write_fmt!(self, "        match root::<flat::{}>(data) {{", self.struct_name);
         write_str!(
             self,
             "            Ok(flat_t) => Ok(crate::into_py_from(py, flat_t.unpack())),"
@@ -924,15 +848,9 @@ impl Generator for StructBindGenerator {
             contents = contents.replace("\r\n", "\n");
         }
 
-        contents = contents.replace(
-            "use self::flatbuffers",
-            "use get_size::GetSize;\nuse self::flatbuffers",
-        );
+        contents = contents.replace("use self::flatbuffers", "use get_size::GetSize;\nuse self::flatbuffers");
 
-        contents = contents.replace(
-            "#[derive(Debug, Clone, PartialEq)]\n",
-            "#[derive(PartialEq, GetSize)]\n",
-        );
+        contents = contents.replace("#[derive(Debug, Clone, PartialEq)]\n", "#[derive(PartialEq, GetSize)]\n");
 
         contents = contents.replace(
             "#[derive(Debug, Clone, PartialEq, Default)]\n",
@@ -992,10 +910,10 @@ impl Generator for StructBindGenerator {
                 RustType::Option(InnerOptionType::BaseType, inner_type) => {
                     format!("Option<Py<{inner_type}>>")
                 }
-                RustType::Option(InnerOptionType::String, _) => {
-                    String::from("Option<Py<PyString>>")
+                RustType::Option(InnerOptionType::String, _) => String::from("Option<Py<PyString>>"),
+                RustType::Union(inner_type, true) | RustType::Option(_, inner_type) => {
+                    format!("Option<Py<super::{inner_type}>>")
                 }
-                RustType::Option(_, inner_type) => format!("Option<Py<super::{inner_type}>>"),
                 RustType::Base(inner_type) => match inner_type.as_str() {
                     "f32" => {
                         add_set = false;
@@ -1004,7 +922,7 @@ impl Generator for StructBindGenerator {
                     _ => inner_type.clone(),
                 },
                 RustType::String => String::from("Py<PyString>"),
-                RustType::Union(inner_type) | RustType::Custom(inner_type) => {
+                RustType::Union(inner_type, false) | RustType::Custom(inner_type) => {
                     format!("Py<super::{inner_type}>")
                 }
                 RustType::Other(inner_type) => format!("super::{inner_type}"),
@@ -1036,14 +954,10 @@ impl Generator for StructBindGenerator {
 
             let end = match &variable_info.rust_type {
                 RustType::Vec(InnerVecType::U8) => Cow::Borrowed("PyBytes::new(py, &[]).unbind()"),
-                RustType::Vec(InnerVecType::Custom(_)) => {
-                    Cow::Borrowed("PyList::empty(py).unbind()")
-                }
+                RustType::Vec(InnerVecType::Custom(_)) => Cow::Borrowed("PyList::empty(py).unbind()"),
                 RustType::Vec(_) => Cow::Borrowed("Vec::new()"),
-                RustType::Option(_, _) => Cow::Borrowed("None"),
-                RustType::Union(inner_type)
-                | RustType::Box(inner_type)
-                | RustType::Custom(inner_type) => {
+                RustType::Union(_, true) | RustType::Option(_, _) => Cow::Borrowed("None"),
+                RustType::Union(inner_type, false) | RustType::Box(inner_type) | RustType::Custom(inner_type) => {
                     Cow::Owned(format!("super::{inner_type}::py_default(py)"))
                 }
                 RustType::Base(inner_type) => Cow::Borrowed(match inner_type.as_str() {
@@ -1081,17 +995,10 @@ impl Generator for StructBindGenerator {
             return;
         }
 
-        write_fmt!(
-            self,
-            "impl FromGil<{impl_type}> for {} {{",
-            self.struct_name
-        );
+        write_fmt!(self, "impl FromGil<{impl_type}> for {} {{", self.struct_name);
 
         write_str!(self, "    #[allow(unused_variables)]");
-        write_fmt!(
-            self,
-            "    fn from_gil(py: Python, flat_t: {impl_type}) -> Self {{"
-        );
+        write_fmt!(self, "    fn from_gil(py: Python, flat_t: {impl_type}) -> Self {{");
         write_fmt!(self, "        {} {{", self.struct_name);
 
         for variable_info in &self.types {
@@ -1137,7 +1044,13 @@ impl Generator for StructBindGenerator {
                         "            {variable_name}: crate::into_py_from(py, *flat_t.{variable_name}),",
                     );
                 }
-                RustType::Union(_) | RustType::Custom(_) => {
+                RustType::Union(inner_type, true) => {
+                    write_fmt!(self, "            {variable_name}: match flat_t.{variable_name} {{");
+                    write_fmt!(self, "                flat::{inner_type}T::NONE => None,");
+                    write_str!(self, "                x => Some(crate::into_py_from(py, x)),");
+                    write_str!(self, "            },");
+                }
+                RustType::Union(_, false) | RustType::Custom(_) => {
                     write_fmt!(
                         self,
                         "            {variable_name}: crate::into_py_from(py, flat_t.{variable_name}),",
@@ -1161,10 +1074,7 @@ impl Generator for StructBindGenerator {
                     }
                 },
                 RustType::Other(_) => {
-                    write_fmt!(
-                        self,
-                        "            {variable_name}: flat_t.{variable_name}.into(),",
-                    );
+                    write_fmt!(self, "            {variable_name}: flat_t.{variable_name}.into(),",);
                 }
             }
         }
@@ -1188,18 +1098,10 @@ impl Generator for StructBindGenerator {
             return;
         }
 
-        write_fmt!(
-            self,
-            "impl FromGil<&{}> for {impl_type} {{",
-            self.struct_name
-        );
+        write_fmt!(self, "impl FromGil<&{}> for {impl_type} {{", self.struct_name);
 
         write_str!(self, "    #[allow(unused_variables)]");
-        write_fmt!(
-            self,
-            "    fn from_gil(py: Python, py_type: &{}) -> Self {{",
-            self.struct_name
-        );
+        write_fmt!(self, "    fn from_gil(py: Python, py_type: &{}) -> Self {{", self.struct_name);
         write_str!(self, "        Self {");
 
         for variable_info in &self.types {
@@ -1213,10 +1115,7 @@ impl Generator for StructBindGenerator {
                     )
                 }
                 RustType::Vec(InnerVecType::String | InnerVecType::Base(_)) => {
-                    write_fmt!(
-                        self,
-                        "            {variable_name}: py_type.{variable_name}.clone(),"
-                    )
+                    write_fmt!(self, "            {variable_name}: py_type.{variable_name}.clone(),")
                 }
                 RustType::Vec(InnerVecType::Custom(_)) => {
                     write_fmt!(
@@ -1248,7 +1147,18 @@ impl Generator for StructBindGenerator {
                         "            {variable_name}: Box::new(crate::from_py_into(py, &py_type.{variable_name})),",
                     );
                 }
-                RustType::Union(_) | RustType::Custom(_) => {
+                RustType::Union(inner_type, true) => {
+                    write_fmt!(self, "            {variable_name}: py_type");
+                    write_fmt!(self, "                .{variable_name}");
+                    write_str!(self, "                .as_ref()");
+                    write_fmt!(self, "                .map_or(flat::{inner_type}T::NONE, |x| {{");
+                    write_fmt!(
+                        self,
+                        "                    crate::from_py_into::<_, flat::{inner_type}T>(py, x).into()"
+                    );
+                    write_str!(self, "                }),");
+                }
+                RustType::Union(_, false) | RustType::Custom(_) => {
                     write_fmt!(
                         self,
                         "            {variable_name}: crate::from_py_into(py, &py_type.{variable_name}),",
@@ -1268,17 +1178,11 @@ impl Generator for StructBindGenerator {
                         );
                     }
                     _ => {
-                        write_fmt!(
-                            self,
-                            "            {variable_name}: py_type.{variable_name},"
-                        );
+                        write_fmt!(self, "            {variable_name}: py_type.{variable_name},");
                     }
                 },
                 RustType::Other(_) => {
-                    write_fmt!(
-                        self,
-                        "            {variable_name}: (&py_type.{variable_name}).into(),",
-                    );
+                    write_fmt!(self, "            {variable_name}: (&py_type.{variable_name}).into(),",);
                 }
             }
         }

{rlbot_flatbuffers-0.14.5 → rlbot_flatbuffers-0.14.6}/codegen/unions.rs

@@ -24,12 +24,7 @@ macro_rules! write_fmt {
 }
 
 impl UnionBindGenerator {
-    pub fn new(
-        filename: String,
-        struct_name: String,
-        struct_t_name: String,
-        types: Vec<CustomEnumType>,
-    ) -> Option<Self> {
+    pub fn new(filename: String, struct_name: String, struct_t_name: String, types: Vec<CustomEnumType>) -> Option<Self> {
         let is_frozen = PythonBindType::FROZEN_TYPES.contains(&struct_name.as_str());
         let is_no_set = PythonBindType::NO_SET_TYPES.contains(&struct_name.as_str());
 
@@ -54,20 +49,13 @@ impl UnionBindGenerator {
         assert!(u8::try_from(self.types.len()).is_ok());
 
         write_str!(self, "    #[new]");
-        write_fmt!(
-            self,
-            "    pub fn new(item: {}Union) -> Self {{",
-            self.struct_name
-        );
+        write_fmt!(self, "    pub fn new(item: {}Union) -> Self {{", self.struct_name);
         write_str!(self, "        Self { item }");
         write_str!(self, "    }");
         write_str!(self, "");
         write_str!(self, "    #[getter(item)]");
 
-        write_str!(
-            self,
-            "    pub fn get(&self, py: Python) -> Option<Py<PyAny>> {"
-        );
+        write_str!(self, "    pub fn get(&self, py: Python) -> Option<Py<PyAny>> {");
         write_str!(self, "        match &self.item {");
 
         for variable_info in &self.types {
@@ -152,11 +140,7 @@ impl UnionBindGenerator {
             let variable_name = variable_info.name.as_str();
 
             if variable_name == "NONE" {
-                write_fmt!(
-                    self,
-                    "            flat::{}::NONE => unreachable!(),",
-                    self.struct_t_name
-                );
+                write_fmt!(self, "            flat::{}::NONE => unreachable!(),", self.struct_t_name);
                 continue;
             }
 
@@ -216,15 +200,9 @@ impl Generator for UnionBindGenerator {
             contents = contents.replace("\r\n", "\n");
         }
 
-        contents = contents.replace(
-            "use self::flatbuffers",
-            "use get_size::GetSize;\nuse self::flatbuffers",
-        );
+        contents = contents.replace("use self::flatbuffers", "use get_size::GetSize;\nuse self::flatbuffers");
 
-        contents = contents.replace(
-            "#[derive(Debug, Clone, PartialEq)]\n",
-            "#[derive(PartialEq, GetSize)]\n",
-        );
+        contents = contents.replace("#[derive(Debug, Clone, PartialEq)]\n", "#[derive(PartialEq, GetSize)]\n");
 
         // delete unneeded auto-generated source code from flatc
         let start = contents.find("impl core::fmt::Debug for ").unwrap();
@@ -291,12 +269,7 @@ impl Generator for UnionBindGenerator {
     }
 
     fn generate_from_flat_impls(&mut self) {
-        write_fmt!(
-            self,
-            "impl FromGil<flat::{}> for {} {{",
-            self.struct_t_name,
-            self.struct_name
-        );
+        write_fmt!(self, "impl FromGil<flat::{}> for {} {{", self.struct_t_name, self.struct_name);
         write_fmt!(
             self,
             "    fn from_gil(py: Python, flat_t: flat::{}) -> Self {{",
@@ -309,11 +282,7 @@ impl Generator for UnionBindGenerator {
             let variable_name = variable_info.name.as_str();
 
             if variable_name == "NONE" {
-                write_fmt!(
-                    self,
-                    "            flat::{}::NONE => unreachable!(),",
-                    self.struct_t_name,
-                );
+                write_fmt!(self, "            flat::{}::NONE => unreachable!(),", self.struct_t_name,);
             } else {
                 write_fmt!(
                     self,
@@ -322,11 +291,7 @@ impl Generator for UnionBindGenerator {
                     self.struct_name,
                 );
 
-                write_fmt!(
-                    self,
-                    "                item: {}Union::{variable_name}(",
-                    self.struct_name
-                );
+                write_fmt!(self, "                item: {}Union::{variable_name}(", self.struct_name);
 
                 write_fmt!(
                     self,
@@ -351,11 +316,7 @@ impl Generator for UnionBindGenerator {
             self.struct_name,
             self.struct_t_name
         );
-        write_fmt!(
-            self,
-            "    fn from_gil(py: Python, py_type: &{}) -> Self {{",
-            self.struct_name
-        );
+        write_fmt!(self, "    fn from_gil(py: Python, py_type: &{}) -> Self {{", self.struct_name);
 
         write_str!(self, "        match &py_type.item {");
 
@@ -363,11 +324,7 @@ impl Generator for UnionBindGenerator {
             let variable_name = variable_info.name.as_str();
 
             if let Some(ref value) = variable_info.value {
-                write_fmt!(
-                    self,
-                    "            {}Union::{value}(item) => {{",
-                    self.struct_name,
-                );
+                write_fmt!(self, "            {}Union::{value}(item) => {{", self.struct_name,);
 
                 write_fmt!(
                     self,

{rlbot_flatbuffers-0.14.5 → rlbot_flatbuffers-0.14.6}/src/lib.rs

@@ -15,19 +15,11 @@ pub mod generated;
 #[allow(clippy::enum_variant_names, clippy::useless_conversion, unused_imports)]
 mod python;
 
-use pyo3::{
-    PyClass, create_exception, exceptions::PyValueError, prelude::*,
-    pyclass::boolean_struct::False, types::*,
-};
+use pyo3::{PyClass, create_exception, exceptions::PyValueError, prelude::*, pyclass::boolean_struct::False, types::*};
 use python::*;
 use std::{panic::Location, path::MAIN_SEPARATOR};
 
-create_exception!(
-    rlbot_flatbuffers,
-    InvalidFlatbuffer,
-    PyValueError,
-    "Invalid FlatBuffer"
-);
+create_exception!(rlbot_flatbuffers, InvalidFlatbuffer, PyValueError, "Invalid FlatBuffer");
 
 #[inline(never)]
 #[track_caller]
@@ -147,11 +139,7 @@ where
 
     for py_item in items.iter() {
         match script_iter.next() {
-            Some(item) => py_item
-                .downcast_into_exact::<U>()
-                .unwrap()
-                .borrow_mut()
-                .unpack_from(py, item),
+            Some(item) => py_item.downcast_into_exact::<U>().unwrap().borrow_mut().unpack_from(py, item),
             None => {
                 let items_len = items.len();
                 for i in 0..items_len - scripts_len {