rlbot-flatbuffers 0.13.0__tar.gz → 0.13.2__tar.gz

{rlbot_flatbuffers-0.13.0 → rlbot_flatbuffers-0.13.2}/Cargo.lock

@@ -279,7 +279,7 @@ dependencies = [
 
 [[package]]
 name = "rlbot_flatbuffers"
-version = "0.13.0"
+version = "0.13.2"
 dependencies = [
  "flatbuffers",
  "get-size",
@@ -298,9 +298,9 @@ dependencies = [
 
 [[package]]
 name = "semver"
-version = "1.0.24"
+version = "1.0.25"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3cb6eb87a131f756572d7fb904f6e7b68633f09cca868c5df1c4b8d1a694bbba"
+checksum = "f79dfe2d285b0488816f30e700a7438c5a73d816b5b7d3ac72fbc48b0d185e03"
 
 [[package]]
 name = "serde"
@@ -330,9 +330,9 @@ checksum = "3c5e1a9a646d36c3599cd173a41282daf47c44583ad367b8e6837255952e5c67"
 
 [[package]]
 name = "syn"
-version = "2.0.96"
+version = "2.0.98"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d5d0adab1ae378d7f53bdebc67a39f1f151407ef230f0ce2883572f5d8985c80"
+checksum = "36147f1a48ae0ec2b5b3bc5b537d267457555a10dc06f3dbc8cb11ba3006d3b1"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -347,9 +347,9 @@ checksum = "61c41af27dd6d1e27b1b16b489db798443478cef1f06a660c96db617ba5de3b1"
 
 [[package]]
 name = "unicode-ident"
-version = "1.0.14"
+version = "1.0.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "adb9e6ca4f869e1180728b7950e35922a7fc6397f7b641499e8f3ef06e50dc83"
+checksum = "a210d160f08b701c8721ba1c726c11662f877ea6b7094007e1ca9a1041945034"
 
 [[package]]
 name = "unindent"

{rlbot_flatbuffers-0.13.0 → rlbot_flatbuffers-0.13.2}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rlbot_flatbuffers"
-version = "0.13.0"
+version = "0.13.2"
 edition = "2021"
 description = "A Python module implemented in Rust for serializing and deserializing RLBot's flatbuffers"
 repository = "https://github.com/VirxEC/rlbot_flatbuffers_py"
@@ -25,6 +25,9 @@ flatbuffers = "=24.12.23"
 # forked and updated deps
 get-size = { git = "https://github.com/VirxEC/get-size", branch = "update", features = ["derive"] }
 
+[profile.dev]
+opt-level = 2
+
 [profile.release]
 lto = true
 strip = true

{rlbot_flatbuffers-0.13.0 → rlbot_flatbuffers-0.13.2}/PKG-INFO

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

{rlbot_flatbuffers-0.13.0 → rlbot_flatbuffers-0.13.2}/codegen/main.rs

@@ -27,7 +27,7 @@ pub enum PythonBindType {
 
 impl PythonBindType {
     pub const BASE_TYPES: [&'static str; 6] = ["bool", "i32", "u32", "f32", "String", "u8"];
-    pub const FROZEN_TYPES: [&'static str; 19] = [
+    pub const FROZEN_TYPES: [&'static str; 21] = [
         "GoalInfo",
         "GamePacket",
         "PlayerInfo",
@@ -47,9 +47,9 @@ impl PythonBindType {
         "ControllableTeamInfo",
         "BoostPad",
         "PredictionSlice",
+        "FieldInfo",
+        "BallPrediction",
     ];
-    pub const SEMI_FROZEN_TYPES: [&'static str; 2] = ["FieldInfo", "BallPrediction"];
-    pub const FROZEN_NEEDS_PY: [&'static str; 3] = ["GamePacket", "BallInfo", "CollisionShape"];
     pub const UNIONS: [&'static str; 4] = [
         "PlayerClass",
         "CollisionShape",

{rlbot_flatbuffers-0.13.0 → rlbot_flatbuffers-0.13.2}/codegen/structs.rs

@@ -39,7 +39,6 @@ pub struct CustomType {
     pub raw_type: String,
     pub rust_type: RustType,
     pub is_frozen: bool,
-    pub frozen_needs_py: bool,
     pub is_special_base: Option<SpecialBase>,
     pub snake_case_name: String,
     pub doc_str: Option<Vec<String>>,
@@ -53,10 +52,7 @@ pub struct StructBindGenerator {
     pub types: Vec<CustomType>,
     file_contents: Vec<Cow<'static, str>>,
     has_complex_pack: bool,
-    is_all_base_types: bool,
     is_frozen: bool,
-    frozen_needs_py: bool,
-    is_semi_frozen: bool,
 }
 
 macro_rules! write_str {
@@ -81,26 +77,17 @@ impl StructBindGenerator {
         types: Vec<CustomType>,
     ) -> Option<Self> {
         let is_frozen = PythonBindType::FROZEN_TYPES.contains(&struct_name.as_str());
-        let frozen_needs_py =
-            is_frozen && PythonBindType::FROZEN_NEEDS_PY.contains(&struct_name.as_str());
-        let is_semi_frozen =
-            !is_frozen && PythonBindType::SEMI_FROZEN_TYPES.contains(&struct_name.as_str());
 
-        let is_all_base_types = types
-            .iter()
-            .all(|t| matches!(t.rust_type, RustType::Base(_)));
         let has_complex_pack =
             contents.contains("pub fn pack<'b, A: flatbuffers::Allocator + 'b>(");
 
         let mut file_contents = vec![];
 
-        file_contents.push(Cow::Borrowed(
-            if (is_frozen && !frozen_needs_py) || is_all_base_types || types.is_empty() {
-                "use crate::{flat_err_to_py, generated::rlbot::flat, FromGil};"
-            } else {
-                "use crate::{flat_err_to_py, generated::rlbot::flat, FromGil, IntoGil, PyDefault};"
-            },
-        ));
+        file_contents.push(Cow::Borrowed(if types.is_empty() {
+            "use crate::{flat_err_to_py, generated::rlbot::flat, FromGil};"
+        } else {
+            "use crate::{flat_err_to_py, generated::rlbot::flat, FromGil, IntoGil, PyDefault};"
+        }));
 
         if has_complex_pack {
             file_contents.push(Cow::Borrowed("use flatbuffers::{root, FlatBufferBuilder};"));
@@ -109,12 +96,7 @@ impl StructBindGenerator {
             file_contents.push(Cow::Borrowed("use flatbuffers::root;"));
         }
 
-        file_contents.push(Cow::Borrowed(if is_frozen {
-            "use pyo3::{pyclass, pymethods, types::PyBytes, Bound, PyResult, Python};"
-        } else {
-            "use pyo3::{pyclass, pymethods, types::{PyAnyMethods, PyBytes, PyList, PyListMethods}, Bound, Py, PyResult, Python};"
-        }));
-
+        file_contents.push(Cow::Borrowed("use pyo3::{prelude::*, types::*};"));
         file_contents.push(Cow::Borrowed(""));
 
         Some(Self {
@@ -125,10 +107,7 @@ impl StructBindGenerator {
             types,
             file_contents,
             has_complex_pack,
-            is_all_base_types,
             is_frozen,
-            frozen_needs_py,
-            is_semi_frozen,
         })
     }
 
@@ -269,30 +248,26 @@ impl StructBindGenerator {
                     (RustType::Other(raw_type.to_string()), Some(raw_type))
                 };
 
-                let (is_frozen, frozen_needs_py, is_special_base) =
-                    if let Some(inner_type) = inner_type {
-                        let is_frozen = PythonBindType::FROZEN_TYPES.contains(&inner_type);
-                        let frozen_needs_py =
-                            is_frozen && PythonBindType::FROZEN_NEEDS_PY.contains(&inner_type);
-                        let is_special_base = if inner_type == "Float" {
-                            Some(SpecialBase::FloatT)
-                        } else if inner_type == "Bool" {
-                            Some(SpecialBase::BoolT)
-                        } else {
-                            None
-                        };
-
-                        (is_frozen, frozen_needs_py, is_special_base)
+                let (is_frozen, is_special_base) = if let Some(inner_type) = inner_type {
+                    let is_frozen = PythonBindType::FROZEN_TYPES.contains(&inner_type);
+                    let is_special_base = if inner_type == "Float" {
+                        Some(SpecialBase::FloatT)
+                    } else if inner_type == "Bool" {
+                        Some(SpecialBase::BoolT)
                     } else {
-                        (false, false, None)
+                        None
                     };
 
+                    (is_frozen, is_special_base)
+                } else {
+                    (false, None)
+                };
+
                 CustomType {
                     name: name.to_string(),
                     raw_type: raw_type.to_string(),
                     rust_type,
                     is_frozen,
-                    frozen_needs_py,
                     is_special_base,
                     snake_case_name: String::new(),
                     doc_str,
@@ -326,28 +301,24 @@ impl StructBindGenerator {
                     format!("{variable_name}=None")
                 }
                 RustType::Union(_) => {
-                    if !self.is_frozen {
-                        needs_python = true;
-                    }
-
+                    needs_python = true;
                     format!("{variable_name}=None")
                 }
                 RustType::Box(_) | RustType::Custom(_) => {
-                    if self.is_frozen {
-                        format!("{variable_name}=Default::default()")
-                    } else {
-                        needs_python = !self.is_frozen;
-                        format!("{variable_name}=None")
-                    }
-                }
-                RustType::Vec(InnerVecType::U8) => {
                     needs_python = true;
                     format!("{variable_name}=None")
                 }
-                RustType::Vec(InnerVecType::Custom(_)) if !self.is_frozen => {
+                RustType::Vec(InnerVecType::U8) | RustType::Vec(InnerVecType::Custom(_)) => {
                     needs_python = true;
-                    format!("{variable_name}=Vec::new()")
+                    format!("{variable_name}=None")
                 }
+                RustType::Base(inner_type) => match inner_type.as_str() {
+                    "f32" => {
+                        needs_python = true;
+                        format!("{variable_name}=Default::default()")
+                    }
+                    _ => format!("{variable_name}=Default::default()"),
+                },
                 _ => {
                     format!("{variable_name}=Default::default()")
                 }
@@ -376,44 +347,39 @@ impl StructBindGenerator {
             let variable_name = variable_info.name.as_str();
 
             let variable_type = match &variable_info.rust_type {
-                RustType::Vec(InnerVecType::Custom(inner_type)) => Cow::Owned(if self.is_frozen {
-                    format!("Vec<super::{inner_type}>")
-                } else {
-                    format!("Vec<Py<super::{inner_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::String) => Cow::Borrowed("Vec<String>"),
                 RustType::Vec(InnerVecType::U8) => Cow::Borrowed("Option<Py<PyBytes>>"),
-                RustType::Box(inner_type) => Cow::Owned(if self.is_frozen {
-                    format!("super::{inner_type}")
-                } else {
-                    format!("Option<Py<super::{inner_type}>>")
-                }),
-                RustType::Option(InnerOptionType::BaseType, inner_type)
-                | RustType::Option(InnerOptionType::String, inner_type) => {
+                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(_, inner_type) => Cow::Owned(if inner_type == "Float" {
-                    String::from("Option<crate::Floats>")
-                } else if inner_type == "Bool" {
-                    String::from("Option<crate::Bools>")
-                } else if self.is_frozen {
-                    format!("Option<super::{inner_type}>")
-                } else {
-                    format!("Option<Py<super::{inner_type}>>")
+                RustType::Option(InnerOptionType::String, _) => {
+                    Cow::Borrowed("Option<Py<PyString>>")
+                }
+                RustType::Option(_, inner_type) => {
+                    if inner_type == "Float" {
+                        Cow::Borrowed("Option<crate::PartFloats>")
+                    } else if inner_type == "Bool" {
+                        Cow::Borrowed("Option<crate::PartBools>")
+                    } else {
+                        Cow::Owned(format!("Option<Py<super::{inner_type}>>"))
+                    }
+                }
+                RustType::Base(inner_type) => Cow::Borrowed(match inner_type.as_str() {
+                    "f32" => "f64",
+                    item => item,
                 }),
-                RustType::Base(inner_type) => Cow::Borrowed(inner_type.as_str()),
                 RustType::String => Cow::Borrowed("String"),
                 RustType::Union(inner_type) => {
                     Cow::Owned(format!("Option<super::{inner_type}Union>"))
                 }
-                RustType::Custom(inner_type) => Cow::Owned(if self.is_frozen {
-                    format!("super::{inner_type}")
-                } else {
-                    format!("Option<Py<super::{inner_type}>>")
-                }),
+                RustType::Custom(inner_type) => {
+                    Cow::Owned(format!("Option<Py<super::{inner_type}>>"))
+                }
                 RustType::Other(inner_type) => Cow::Owned(format!("super::{inner_type}")),
             };
 
@@ -436,21 +402,13 @@ impl StructBindGenerator {
 
             match &variable_info.rust_type {
                 RustType::Union(inner_type) => {
-                    if self.is_frozen {
-                        write_fmt!(
-                            self,
-                            "            {variable_name}: super::{}::new({variable_name}),",
-                            inner_type
-                        );
-                    } else {
-                        write_fmt!(
-                            self,
-                            "            {variable_name}: Py::new(py, super::{}::new({variable_name})).unwrap(),",
-                            inner_type
-                        );
-                    }
+                    write_fmt!(
+                        self,
+                        "            {variable_name}: Py::new(py, super::{}::new({variable_name})).unwrap(),",
+                        inner_type
+                    );
                 }
-                RustType::Box(inner_type) | RustType::Custom(inner_type) if !self.is_frozen => {
+                RustType::Box(inner_type) | RustType::Custom(inner_type) => {
                     write_fmt!(self, "            {variable_name}: {variable_name}.unwrap_or_else(|| super::{inner_type}::py_default(py)),",);
                 }
                 RustType::Vec(InnerVecType::U8) => {
@@ -459,12 +417,19 @@ impl StructBindGenerator {
                         "            {variable_name}: {variable_name}.unwrap_or_else(|| PyBytes::new(py, &[]).unbind()),"
                     );
                 }
-                RustType::Vec(InnerVecType::Custom(_)) if !self.is_frozen => {
+                RustType::Vec(InnerVecType::Custom(_)) => {
                     write_fmt!(
                         self,
-                        "            {variable_name}: PyList::new(py, {variable_name}).unwrap().unbind(),"
+                        "            {variable_name}: {variable_name}.unwrap_or_else(|| PyList::empty(py).unbind()),"
                     );
                 }
+                RustType::Base(inner_type) => match inner_type.as_str() {
+                    "f32" => write_fmt!(
+                        self,
+                        "            {variable_name}: PyFloat::new(py, {variable_name}).unbind(),"
+                    ),
+                    _ => write_fmt!(self, "            {variable_name},"),
+                },
                 _ => write_fmt!(self, "            {variable_name},"),
             }
         }
@@ -487,10 +452,7 @@ impl StructBindGenerator {
             return;
         }
 
-        if !self.frozen_needs_py {
-            write_str!(self, "    #[allow(unused_variables)]");
-        }
-
+        write_str!(self, "    #[allow(unused_variables)]");
         write_str!(self, "    pub fn __repr__(&self, py: Python) -> String {");
         write_str!(self, "        format!(");
 
@@ -536,16 +498,9 @@ impl StructBindGenerator {
                             write_str!(self, "                .map(ToString::to_string)");
                         }
                         InnerVecType::Custom(type_name) => {
-                            if !self.is_frozen {
-                                write_str!(self, "                .bind_borrowed(py)");
-                            }
-
+                            write_str!(self, "                .bind_borrowed(py)");
                             write_str!(self, "                .iter()");
-                            if self.is_frozen {
-                                write_str!(self, "                .map(|x| x.__repr__(py))");
-                            } else {
-                                write_fmt!(self, "                .map(|x| x.downcast_into::<super::{type_name}>().unwrap().borrow().__repr__(py))");
-                            }
+                            write_fmt!(self, "                .map(|x| x.downcast_into::<super::{type_name}>().unwrap().borrow().__repr__(py))");
                         }
                     }
                     write_str!(self, "                .collect::<Vec<String>>()");
@@ -556,40 +511,30 @@ impl StructBindGenerator {
                     write_str!(self, "                .as_ref()");
 
                     match inner_type {
-                        InnerOptionType::BaseType | InnerOptionType::String => {
+                        InnerOptionType::BaseType => {
                             write_str!(self, "                .map(|i| format!(\"{i:?}\"))");
                         }
+                        InnerOptionType::String => {
+                            write_str!(self, "                .map(|i| format!(\"{:?}\", i.to_str(py).unwrap().to_string()))");
+                        }
                         _ => {
-                            write_str!(
-                                self,
-                                if self.is_frozen {
-                                    "                .map(|x| x.__repr__(py))"
-                                } else {
-                                    "                .map(|x| x.borrow(py).__repr__(py))"
-                                }
-                            );
+                            write_str!(self, "                .map(|x| x.borrow(py).__repr__(py))");
                         }
                     }
 
                     write_str!(self, "                .unwrap_or_else(crate::none_str),");
                 }
                 RustType::Union(_) => {
-                    let repr_str = if self.is_frozen {
-                        ".inner_repr(py)"
-                    } else {
-                        ".borrow(py).inner_repr(py)"
-                    };
-
-                    write_fmt!(self, "            self.{variable_name}{repr_str},");
+                    write_fmt!(
+                        self,
+                        "            self.{variable_name}.borrow(py).inner_repr(py),"
+                    );
                 }
                 RustType::Box(_) | RustType::Custom(_) => {
-                    let repr_str = if self.is_frozen {
-                        ".__repr__(py)"
-                    } else {
-                        ".borrow(py).__repr__(py)"
-                    };
-
-                    write_fmt!(self, "            self.{variable_name}{repr_str},");
+                    write_fmt!(
+                        self,
+                        "            self.{variable_name}.borrow(py).__repr__(py),"
+                    );
                 }
                 RustType::Base(inner_type) => {
                     if inner_type == "bool" {
@@ -614,45 +559,53 @@ impl StructBindGenerator {
         write_str!(self, "    }");
     }
 
-    fn generate_long_match_args(&mut self) {
-        write_str!(self, "    #[classattr]");
-        write_str!(
-            self,
-            "    fn __match_args__(py: Python) -> Bound<pyo3::types::PyTuple> {"
-        );
-        write_str!(self, "        pyo3::types::PyTuple::new(py, [");
+    fn generate_long_args(&mut self) {
+        let funcs = ["match_args", "slots"];
 
-        for variable_info in &self.types {
-            write_fmt!(self, "            \"{}\",", variable_info.name);
-        }
+        for func in funcs {
+            write_str!(self, "    #[classattr]");
+            write_fmt!(
+                self,
+                "    fn __{func}__(py: Python) -> Bound<pyo3::types::PyTuple> {{"
+            );
+            write_str!(self, "        pyo3::types::PyTuple::new(py, [");
 
-        write_str!(self, "        ]).unwrap()");
-        write_str!(self, "    }");
+            for variable_info in &self.types {
+                write_fmt!(self, "            \"{}\",", variable_info.name);
+            }
+
+            write_str!(self, "        ]).unwrap()");
+            write_str!(self, "    }\n");
+        }
     }
 
-    fn generate_match_args(&mut self) {
+    fn generate_args(&mut self) {
         if self.types.is_empty() {
             return;
         }
 
         if self.types.len() > 12 {
-            self.generate_long_match_args();
+            self.generate_long_args();
             return;
         }
 
         let sig_parts: Vec<_> = repeat("&'static str").take(self.types.len()).collect();
         let sig = sig_parts.join(", ");
 
-        write_str!(self, "    #[classattr]");
-        write_fmt!(self, "    fn __match_args__() -> ({sig},) {{",);
-        write_str!(self, "        (");
+        let funcs = ["match_args", "slots"];
 
-        for variable_info in &self.types {
-            write_fmt!(self, "            \"{}\",", variable_info.name);
-        }
+        for func in funcs {
+            write_str!(self, "    #[classattr]");
+            write_fmt!(self, "    fn __{func}__() -> ({sig},) {{",);
+            write_str!(self, "        (");
 
-        write_str!(self, "        )");
-        write_str!(self, "    }");
+            for variable_info in &self.types {
+                write_fmt!(self, "            \"{}\",", variable_info.name);
+            }
+
+            write_str!(self, "        )");
+            write_str!(self, "    }\n");
+        }
     }
 
     fn generate_pack_method(&mut self) {
@@ -692,9 +645,7 @@ impl StructBindGenerator {
     fn generate_unpack_method(&mut self) {
         write_str!(self, "    #[staticmethod]");
 
-        let (py_arg, return_val, out_map) = if self.frozen_needs_py {
-            ("py: Python, ", "Self", "flat_t.unpack().into_gil(py)")
-        } else if self.is_frozen {
+        let (py_arg, return_val, out_map) = if false {
             ("", "Self", "flat_t.unpack().into()")
         } else {
             (
@@ -764,8 +715,6 @@ impl Generator for StructBindGenerator {
             self,
             if self.is_frozen {
                 "#[pyclass(module = \"rlbot_flatbuffers\", subclass, get_all, frozen)]"
-            } else if self.is_semi_frozen {
-                "#[pyclass(module = \"rlbot_flatbuffers\", subclass, get_all)]"
             } else if self.types.is_empty() {
                 "#[pyclass(module = \"rlbot_flatbuffers\", subclass, frozen)]"
             } else {
@@ -774,26 +723,12 @@ impl Generator for StructBindGenerator {
         );
 
         if self.types.is_empty() {
-            write_str!(self, "#[derive(Debug, Default, Clone, Copy)]");
+            write_str!(self, "#[derive(Default)]");
             write_fmt!(self, "pub struct {} {{}}", self.struct_name);
             write_str!(self, "");
             return;
         }
 
-        write_str!(
-            self,
-            if self.is_frozen || self.is_all_base_types {
-                if !self.is_all_base_types
-                    || self.types.iter().any(|t| t.rust_type == RustType::String)
-                {
-                    "#[derive(Debug, Default, Clone)]"
-                } else {
-                    "#[derive(Debug, Default, Clone, Copy)]"
-                }
-            } else {
-                "#[derive(Debug)]"
-            }
-        );
         write_fmt!(self, "pub struct {} {{", self.struct_name);
 
         for variable_info in &self.types {
@@ -803,39 +738,22 @@ impl Generator for StructBindGenerator {
                 RustType::Vec(InnerVecType::U8) => String::from("Py<PyBytes>"),
                 RustType::Vec(InnerVecType::String) => String::from("Vec<String>"),
                 RustType::Vec(InnerVecType::Base(inner_type)) => format!("Vec<{}>", inner_type),
-                RustType::Vec(InnerVecType::Custom(inner_type)) => {
-                    if self.is_frozen {
-                        format!("Vec<super::{inner_type}>")
-                    } else {
-                        String::from("Py<PyList>")
-                    }
+                RustType::Vec(InnerVecType::Custom(_)) => String::from("Py<PyList>"),
+                RustType::Box(inner_type) => format!("Py<super::{inner_type}>"),
+                RustType::Option(InnerOptionType::BaseType, inner_type) => {
+                    format!("Option<Py<{inner_type}>>")
                 }
-                RustType::Box(inner_type) => {
-                    if self.is_frozen {
-                        format!("super::{inner_type}")
-                    } else {
-                        format!("Py<super::{inner_type}>")
-                    }
-                }
-                RustType::Option(InnerOptionType::BaseType, inner_type)
-                | RustType::Option(InnerOptionType::String, inner_type) => {
-                    format!("Option<{inner_type}>")
-                }
-                RustType::Option(_, inner_type) => {
-                    if self.is_frozen {
-                        format!("Option<super::{inner_type}>")
-                    } else {
-                        format!("Option<Py<super::{inner_type}>>")
-                    }
+                RustType::Option(InnerOptionType::String, _) => {
+                    String::from("Option<Py<PyString>>")
                 }
-                RustType::Base(inner_type) => inner_type.clone(),
+                RustType::Option(_, inner_type) => format!("Option<Py<super::{inner_type}>>"),
+                RustType::Base(inner_type) => match inner_type.as_str() {
+                    "f32" => String::from("Py<PyFloat>"),
+                    _ => inner_type.clone(),
+                },
                 RustType::String => String::from("String"),
                 RustType::Union(inner_type) | RustType::Custom(inner_type) => {
-                    if self.is_frozen {
-                        format!("super::{inner_type}")
-                    } else {
-                        format!("Py<super::{inner_type}>")
-                    }
+                    format!("Py<super::{inner_type}>")
                 }
                 RustType::Other(inner_type) => format!("super::{inner_type}"),
             };
@@ -846,14 +764,6 @@ impl Generator for StructBindGenerator {
         write_str!(self, "}");
         write_str!(self, "");
 
-        if self.is_all_base_types {
-            return;
-        }
-
-        if self.is_frozen {
-            return;
-        }
-
         write_fmt!(self, "impl crate::PyDefault for {} {{", self.struct_name);
         write_str!(self, "    fn py_default(py: Python) -> Py<Self> {");
         write_str!(self, "        Py::new(py, Self {");
@@ -863,7 +773,7 @@ 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(_)) if !self.is_frozen => {
+                RustType::Vec(InnerVecType::Custom(_)) => {
                     Cow::Borrowed("PyList::empty(py).unbind()")
                 }
                 RustType::Vec(_) => Cow::Borrowed("Vec::new()"),
@@ -873,20 +783,17 @@ impl Generator for StructBindGenerator {
                 | RustType::Custom(inner_type) => {
                     Cow::Owned(format!("super::{inner_type}::py_default(py)"))
                 }
-                RustType::String | RustType::Base(_) | RustType::Other(_) => {
-                    Cow::Borrowed("Default::default()")
-                }
+                RustType::Base(inner_type) => Cow::Borrowed(match inner_type.as_str() {
+                    "f32" => "crate::pyfloat_default(py)",
+                    _ => "Default::default()",
+                }),
+                RustType::String | RustType::Other(_) => Cow::Borrowed("Default::default()"),
             };
 
             write_fmt!(self, "            {variable_name}: {end},");
         }
 
-        if self.is_frozen {
-            write_str!(self, "        }");
-        } else {
-            write_str!(self, "        }).unwrap()");
-        }
-
+        write_str!(self, "        }).unwrap()");
         write_str!(self, "    }");
         write_str!(self, "}");
         write_str!(self, "");
@@ -905,26 +812,16 @@ impl Generator for StructBindGenerator {
             return;
         }
 
-        let (is_simple, trait_name, fn_name, python_arg) =
-            if (self.is_frozen && !self.frozen_needs_py) || self.is_all_base_types {
-                (true, "From", "from", "")
-            } else {
-                (false, "FromGil", "from_gil", "py: Python, ")
-            };
-
         write_fmt!(
             self,
-            "impl {trait_name}<{impl_type}> for {} {{",
+            "impl FromGil<{impl_type}> for {} {{",
             self.struct_name
         );
 
-        if !is_simple {
-            write_str!(self, "    #[allow(unused_variables)]")
-        }
-
+        write_str!(self, "    #[allow(unused_variables)]");
         write_fmt!(
             self,
-            "    fn {fn_name}({python_arg}flat_t: {impl_type}) -> Self {{"
+            "    fn from_gil(py: Python, flat_t: {impl_type}) -> Self {{"
         );
         write_fmt!(self, "        {} {{", self.struct_name);
 
@@ -942,38 +839,19 @@ impl Generator for StructBindGenerator {
                     write_fmt!(self, "            {variable_name}: flat_t.{variable_name},")
                 }
                 RustType::Vec(InnerVecType::Custom(type_name)) => {
-                    if self.is_frozen {
-                        let map_out = if variable_info.frozen_needs_py {
-                            "|x| x.into_gil(py)"
-                        } else {
-                            "Into::into"
-                        };
-
-                        write_fmt!(
-                            self,
-                            "            {variable_name}: flat_t.{variable_name}.into_iter().map({map_out}).collect(),"
-                        )
-                    } else {
-                        write_fmt!(
-                            self,
-                            "            {variable_name}: PyList::new(py, flat_t.{variable_name}.into_iter().map(|x| crate::into_py_from::<_, super::{type_name}>(py, x))).unwrap().unbind(),",
-                        )
-                    }
+                    write_fmt!(
+                        self,
+                        "            {variable_name}: PyList::new(py, flat_t.{variable_name}.into_iter().map(|x| crate::into_py_from::<_, super::{type_name}>(py, x))).unwrap().unbind(),",
+                    )
                 }
                 RustType::Option(InnerOptionType::Box, _) => {
-                    let inner = if self.is_frozen {
-                        "(*x).into()"
-                    } else {
-                        "crate::into_py_from(py, *x)"
-                    };
-
                     write_fmt!(
                         self,
-                        "            {variable_name}: flat_t.{variable_name}.map(|x| {inner}),"
+                        "            {variable_name}: flat_t.{variable_name}.map(|x| crate::into_py_from(py, *x)),"
                     );
                 }
                 RustType::Option(InnerOptionType::String, _) => {
-                    write_fmt!(self, "            {variable_name}: flat_t.{variable_name},");
+                    write_fmt!(self, "            {variable_name}: flat_t.{variable_name}.map(|s| PyString::new(py, &s).unbind()),");
                 }
                 RustType::Option(_, _) => {
                     write_fmt!(
@@ -982,33 +860,22 @@ impl Generator for StructBindGenerator {
                     );
                 }
                 RustType::Box(_) => {
-                    let end = if self.is_frozen {
-                        if variable_info.frozen_needs_py {
-                            format!("(*flat_t.{variable_name}).into_gil(py)",)
-                        } else {
-                            format!("(*flat_t.{variable_name}).into()",)
-                        }
-                    } else {
-                        format!("crate::into_py_from(py, *flat_t.{variable_name})")
-                    };
-                    write_fmt!(self, "            {variable_name}: {end},",);
+                    write_fmt!(self, "            {variable_name}: crate::into_py_from(py, *flat_t.{variable_name}),",);
                 }
                 RustType::Union(_) | RustType::Custom(_) => {
-                    let end = if self.is_frozen {
-                        if variable_info.frozen_needs_py {
-                            format!("flat_t.{variable_name}.into_gil(py)")
-                        } else {
-                            format!("flat_t.{variable_name}.into()")
-                        }
-                    } else {
-                        format!("crate::into_py_from(py, flat_t.{variable_name})")
-                    };
-
-                    write_fmt!(self, "            {variable_name}: {end},",);
+                    write_fmt!(self, "            {variable_name}: crate::into_py_from(py, flat_t.{variable_name}),",);
                 }
-                RustType::Base(_) | RustType::String => {
+                RustType::String => {
                     write_fmt!(self, "            {variable_name}: flat_t.{variable_name},");
                 }
+                RustType::Base(inner_type) => match inner_type.as_str() {
+                    "f32" => {
+                        write_fmt!(self, "            {variable_name}: crate::float_to_py(py, flat_t.{variable_name}),");
+                    }
+                    _ => {
+                        write_fmt!(self, "            {variable_name}: flat_t.{variable_name},");
+                    }
+                },
                 RustType::Other(_) => {
                     write_fmt!(
                         self,
@@ -1037,26 +904,16 @@ impl Generator for StructBindGenerator {
             return;
         }
 
-        let (is_simple, trait_name, fn_name, python_arg) =
-            if (self.is_frozen && !self.frozen_needs_py) || self.is_all_base_types {
-                (true, "From", "from", "")
-            } else {
-                (false, "FromGil", "from_gil", "py: Python, ")
-            };
-
         write_fmt!(
             self,
-            "impl {trait_name}<&{}> for {impl_type} {{",
+            "impl FromGil<&{}> for {impl_type} {{",
             self.struct_name
         );
 
-        if !is_simple {
-            write_str!(self, "    #[allow(unused_variables)]")
-        }
-
+        write_str!(self, "    #[allow(unused_variables)]");
         write_fmt!(
             self,
-            "    fn {fn_name}({python_arg}py_type: &{}) -> Self {{",
+            "    fn from_gil(py: Python, py_type: &{}) -> Self {{",
             self.struct_name
         );
         write_str!(self, "        Self {");
@@ -1078,40 +935,21 @@ impl Generator for StructBindGenerator {
                     )
                 }
                 RustType::Vec(InnerVecType::Custom(_)) => {
-                    if self.is_frozen {
-                        let map_out = if variable_info.frozen_needs_py {
-                            "|x| x.into_gil(py)"
-                        } else {
-                            "Into::into"
-                        };
-
-                        write_fmt!(
-                            self,
-                            "            {variable_name}: py_type.{variable_name}.iter().map({map_out}).collect(),"
-                        )
-                    } else {
-                        write_fmt!(
-                            self,
-                            "            {variable_name}: py_type.{variable_name}.bind_borrowed(py).iter().map(|x| crate::from_pyany_into(py, x)).collect(),",
-                        )
-                    }
+                    write_fmt!(
+                        self,
+                        "            {variable_name}: py_type.{variable_name}.bind_borrowed(py).iter().map(|x| crate::from_pyany_into(py, x)).collect(),",
+                    )
                 }
                 RustType::Option(InnerOptionType::Box, _) => {
-                    let inner = if self.is_frozen {
-                        "x.into()"
-                    } else {
-                        "crate::from_py_into(py, x)"
-                    };
-
                     write_fmt!(
                         self,
-                        "            {variable_name}: py_type.{variable_name}.as_ref().map(|x| Box::new({inner})),"
+                        "            {variable_name}: py_type.{variable_name}.as_ref().map(|x| Box::new(crate::from_py_into(py, x))),"
                     );
                 }
                 RustType::Option(InnerOptionType::String, _) => {
                     write_fmt!(
                         self,
-                        "            {variable_name}: py_type.{variable_name}.clone(),"
+                        "            {variable_name}: py_type.{variable_name}.as_ref().map(|s| s.to_str(py).unwrap().to_string()),"
                     );
                 }
                 RustType::Option(_, _) => {
@@ -1121,30 +959,10 @@ impl Generator for StructBindGenerator {
                     );
                 }
                 RustType::Box(_) => {
-                    let var_name = if self.is_frozen {
-                        if variable_info.frozen_needs_py {
-                            format!("(&py_type.{variable_name}).into_gil(py)")
-                        } else {
-                            format!("(&py_type.{variable_name}).into()")
-                        }
-                    } else {
-                        format!("crate::from_py_into(py, &py_type.{variable_name})")
-                    };
-
-                    write_fmt!(self, "            {variable_name}: Box::new({var_name}),",);
+                    write_fmt!(self, "            {variable_name}: Box::new(crate::from_py_into(py, &py_type.{variable_name})),",);
                 }
                 RustType::Union(_) | RustType::Custom(_) => {
-                    let end = if self.is_frozen {
-                        if variable_info.frozen_needs_py {
-                            format!("(&py_type.{variable_name}).into_gil(py)")
-                        } else {
-                            format!("(&py_type.{variable_name}).into()")
-                        }
-                    } else {
-                        format!("crate::from_py_into(py, &py_type.{variable_name})")
-                    };
-
-                    write_fmt!(self, "            {variable_name}: {end},",);
+                    write_fmt!(self, "            {variable_name}: crate::from_py_into(py, &py_type.{variable_name}),",);
                 }
                 RustType::String => {
                     write_fmt!(
@@ -1152,12 +970,20 @@ impl Generator for StructBindGenerator {
                         "            {variable_name}: py_type.{variable_name}.clone(),",
                     );
                 }
-                RustType::Base(_) => {
-                    write_fmt!(
-                        self,
-                        "            {variable_name}: py_type.{variable_name},"
-                    );
-                }
+                RustType::Base(inner_type) => match inner_type.as_str() {
+                    "f32" => {
+                        write_fmt!(
+                                self,
+                                "            {variable_name}: crate::float_from_py(py, &py_type.{variable_name}),"
+                            );
+                    }
+                    _ => {
+                        write_fmt!(
+                            self,
+                            "            {variable_name}: py_type.{variable_name},"
+                        );
+                    }
+                },
                 RustType::Other(_) => {
                     write_fmt!(
                         self,
@@ -1186,8 +1012,7 @@ impl Generator for StructBindGenerator {
         self.generate_repr_method();
         write_str!(self, "");
 
-        self.generate_match_args();
-        write_str!(self, "");
+        self.generate_args();
 
         self.generate_pack_method();
         write_str!(self, "");

{rlbot_flatbuffers-0.13.0 → rlbot_flatbuffers-0.13.2}/codegen/unions.rs

@@ -50,12 +50,6 @@ impl UnionBindGenerator {
     fn generate_new_method(&mut self) {
         assert!(u8::try_from(self.types.len()).is_ok());
 
-        let item_str = if self.is_frozen {
-            "Bound::new(py, *item).unwrap().into_any()"
-        } else {
-            "item.clone_ref(py).into_any()"
-        };
-
         write_str!(self, "    #[new]");
         write_str!(self, "    #[pyo3(signature = (item = None))]");
         write_fmt!(
@@ -68,17 +62,10 @@ impl UnionBindGenerator {
         write_str!(self, "");
         write_str!(self, "    #[getter(item)]");
 
-        if self.is_frozen {
-            write_str!(
-                self,
-                "    pub fn get<'a>(&self, py: Python<'a>) -> Option<Bound<'a, PyAny>> {"
-            );
-        } else {
-            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.as_ref() {");
 
         for variable_info in &self.types {
@@ -89,7 +76,7 @@ impl UnionBindGenerator {
             } else {
                 write_fmt!(
                     self,
-                    "            Some({}Union::{variable_name}(item)) => Some({item_str}),",
+                    "            Some({}Union::{variable_name}(item)) => Some(item.clone_ref(py).into_any()),",
                     self.struct_name
                 );
             }
@@ -109,15 +96,13 @@ impl UnionBindGenerator {
         write_str!(self, "    pub fn inner_repr(&self, py: Python) -> String {");
         write_str!(self, "        match self.item.as_ref() {");
 
-        let borrow_str = if self.is_frozen { "" } else { ".borrow(py)" };
-
         for variable_info in &self.types {
             let variable_name = variable_info.name.as_str();
 
             if variable_info.value.is_some() {
                 write_fmt!(
                     self,
-                    "            Some({}Union::{variable_name}(item)) => item{borrow_str}.__repr__(py),",
+                    "            Some({}Union::{variable_name}(item)) => item.borrow(py).__repr__(py),",
                     self.struct_name
                 );
             } else {
@@ -133,15 +118,13 @@ impl UnionBindGenerator {
         write_str!(self, "    pub fn __repr__(&self, py: Python) -> String {");
         write_str!(self, "        match self.item.as_ref() {");
 
-        let borrow_str = if self.is_frozen { "" } else { ".borrow(py)" };
-
         for variable_info in &self.types {
             let variable_name = variable_info.name.as_str();
 
             if variable_info.value.is_some() {
                 write_fmt!(
                     self,
-                    "            Some({}Union::{variable_name}(item)) => format!(\"{}({{}})\", item{borrow_str}.__repr__(py)),",
+                    "            Some({}Union::{variable_name}(item)) => format!(\"{}({{}})\", item.borrow(py).__repr__(py)),",
                     self.struct_name,
                     self.struct_name
                 );
@@ -194,18 +177,13 @@ impl Generator for UnionBindGenerator {
     }
 
     fn generate_definition(&mut self) {
-        let clone_str = if self.is_frozen { ", Clone" } else { "" };
-        write_fmt!(self, "#[derive(Debug{clone_str}, pyo3::FromPyObject)]");
+        write_fmt!(self, "#[derive(Debug, pyo3::FromPyObject)]");
         write_fmt!(self, "pub enum {}Union {{", self.struct_name);
 
         for variable_info in self.types.iter().skip(1) {
             let variable_name = variable_info.name.as_str();
 
-            if self.is_frozen {
-                write_fmt!(self, "    {variable_name}(super::{variable_name}),");
-            } else {
-                write_fmt!(self, "    {variable_name}(Py<super::{variable_name}>),");
-            }
+            write_fmt!(self, "    {variable_name}(Py<super::{variable_name}>),");
         }
 
         write_str!(self, "}");
@@ -217,7 +195,7 @@ impl Generator for UnionBindGenerator {
             write_str!(self, "#[pyclass(module = \"rlbot_flatbuffers\")]");
         }
 
-        write_fmt!(self, "#[derive(Debug, Default{clone_str})]");
+        write_fmt!(self, "#[derive(Debug, Default)]");
         write_fmt!(self, "pub struct {} {{", self.struct_name);
 
         if !self.is_frozen {
@@ -230,21 +208,15 @@ impl Generator for UnionBindGenerator {
     }
 
     fn generate_from_flat_impls(&mut self) {
-        let (trait_name, fn_name, python_arg) = if self.is_frozen {
-            ("From", "from", "")
-        } else {
-            ("FromGil", "from_gil", "py: Python, ")
-        };
-
         write_fmt!(
             self,
-            "impl {trait_name}<flat::{}> for {} {{",
+            "impl FromGil<flat::{}> for {} {{",
             self.struct_t_name,
             self.struct_name
         );
         write_fmt!(
             self,
-            "    fn {fn_name}({python_arg}flat_t: flat::{}) -> Self {{",
+            "    fn from_gil(py: Python, flat_t: flat::{}) -> Self {{",
             self.struct_t_name
         );
 
@@ -274,17 +246,10 @@ impl Generator for UnionBindGenerator {
                     self.struct_name
                 );
 
-                if self.is_frozen {
-                    write_fmt!(
-                        self,
-                        "                    super::{variable_name}::from(*item),"
-                    );
-                } else {
-                    write_fmt!(
-                        self,
-                        "                    Py::new(py, super::{variable_name}::from_gil(py, *item)).unwrap(),"
-                    );
-                }
+                write_fmt!(
+                    self,
+                    "                    Py::new(py, super::{variable_name}::from_gil(py, *item)).unwrap(),"
+                );
 
                 write_fmt!(self, "                )),");
                 write_fmt!(self, "            }},");
@@ -298,21 +263,15 @@ impl Generator for UnionBindGenerator {
     }
 
     fn generate_to_flat_impls(&mut self) {
-        let (trait_name, fn_name, python_arg) = if self.is_frozen {
-            ("From", "from", "")
-        } else {
-            ("FromGil", "from_gil", "py: Python, ")
-        };
-
         write_fmt!(
             self,
-            "impl {trait_name}<&{}> for flat::{} {{",
+            "impl FromGil<&{}> for flat::{} {{",
             self.struct_name,
             self.struct_t_name
         );
         write_fmt!(
             self,
-            "    fn {fn_name}({python_arg}py_type: &{}) -> Self {{",
+            "    fn from_gil(py: Python, py_type: &{}) -> Self {{",
             self.struct_name
         );
 
@@ -328,19 +287,11 @@ impl Generator for UnionBindGenerator {
                     self.struct_name,
                 );
 
-                if self.is_frozen {
-                    write_fmt!(
-                        self,
-                        "                flat::{}::{variable_name}(Box::new(item.into()))",
-                        self.struct_t_name
-                    );
-                } else {
-                    write_fmt!(
-                        self,
-                        "                flat::{}::{variable_name}(Box::new(crate::from_py_into(py, item)))",
-                        self.struct_t_name
-                    );
-                }
+                write_fmt!(
+                    self,
+                    "                flat::{}::{variable_name}(Box::new(crate::from_py_into(py, item)))",
+                    self.struct_t_name
+                );
 
                 write_str!(self, "            },");
             } else {

{rlbot_flatbuffers-0.13.0 → rlbot_flatbuffers-0.13.2}/src/lib.rs

@@ -14,7 +14,7 @@ pub mod generated;
 #[allow(clippy::enum_variant_names, clippy::useless_conversion, unused_imports)]
 mod python;
 
-use pyo3::{create_exception, exceptions::PyValueError, prelude::*, PyClass};
+use pyo3::{create_exception, exceptions::PyValueError, prelude::*, types::*, PyClass};
 use python::*;
 use std::{panic::Location, path::MAIN_SEPARATOR};
 
@@ -100,6 +100,24 @@ impl<T: Default + PyClass + Into<PyClassInitializer<T>>> PyDefault for T {
     }
 }
 
+#[must_use]
+#[inline(never)]
+pub fn pyfloat_default(py: Python) -> Py<PyFloat> {
+    PyFloat::new(py, 0.0).unbind()
+}
+
+#[must_use]
+#[inline(never)]
+pub fn float_to_py(py: Python, num: f32) -> Py<PyFloat> {
+    PyFloat::new(py, num as f64).unbind()
+}
+
+#[must_use]
+#[inline(never)]
+pub fn float_from_py(py: Python, num: &Py<PyFloat>) -> f32 {
+    num.bind(py).value() as f32
+}
+
 #[must_use]
 #[inline(never)]
 pub fn none_str() -> String {
@@ -116,32 +134,38 @@ pub const fn bool_to_str(b: bool) -> &'static str {
     }
 }
 
-#[derive(Debug, FromPyObject)]
-pub enum Floats {
-    Num(f32),
+#[derive(FromPyObject)]
+pub enum PartFloats {
+    Float(f64),
     Flat(Py<Float>),
 }
 
-impl FromGil<Floats> for Py<Float> {
-    fn from_gil(py: Python, floats: Floats) -> Self {
+impl FromGil<PartFloats> for Py<Float> {
+    fn from_gil(py: Python, floats: PartFloats) -> Self {
         match floats {
-            Floats::Flat(float) => float,
-            Floats::Num(num) => Py::new(py, Float::new(num)).unwrap(),
+            PartFloats::Float(num) => Py::new(
+                py,
+                Float {
+                    val: PyFloat::new(py, num).unbind(),
+                },
+            )
+            .unwrap(),
+            PartFloats::Flat(float) => float,
         }
     }
 }
 
-#[derive(Debug, FromPyObject)]
-pub enum Bools {
+#[derive(FromPyObject)]
+pub enum PartBools {
     Num(bool),
     Flat(Py<Bool>),
 }
 
-impl FromGil<Bools> for Py<Bool> {
-    fn from_gil(py: Python, bools: Bools) -> Self {
+impl FromGil<PartBools> for Py<Bool> {
+    fn from_gil(py: Python, bools: PartBools) -> Self {
         match bools {
-            Bools::Flat(float) => float,
-            Bools::Num(num) => Py::new(py, Bool::new(num)).unwrap(),
+            PartBools::Flat(float) => float,
+            PartBools::Num(num) => Py::new(py, Bool::new(num)).unwrap(),
         }
     }
 }
@@ -149,7 +173,7 @@ impl FromGil<Bools> for Py<Bool> {
 macro_rules! pynamedmodule {
     (doc: $doc:literal, name: $name:tt, classes: [$($class_name:ident),*], vars: [$(($var_name:literal, $value:expr)),*], exceptions: [$($except:expr),*]) => {
         #[doc = $doc]
-        #[pymodule]
+        #[pymodule(gil_used = false)]
         #[allow(redundant_semicolons)]
         fn $name(py: Python, m: Bound<PyModule>) -> PyResult<()> {
             $(m.add_class::<$class_name>()?);*;