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

{rlbot_flatbuffers-0.14.5 → rlbot_flatbuffers-0.14.7}/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.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "945462a4b81e43c4e3ba96bd7b49d834c6f61198356aa858733bc4acf3cbe62e"
+checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d"
 
 [[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.7"
 dependencies = [
  "flatbuffers",
  "get-size",

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

@@ -1,6 +1,6 @@
 [package]
 name = "rlbot_flatbuffers"
-version = "0.14.5"
+version = "0.14.7"
 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.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rlbot_flatbuffers
-Version: 0.14.5
+Version: 0.14.7
 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.7}/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.7}/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.7}/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, "    ): ...");