polyxml 0.23.3__tar.gz → 0.24.0__tar.gz

{polyxml-0.23.3 → polyxml-0.24.0}/Cargo.lock

@@ -608,7 +608,7 @@ dependencies = [
 
 [[package]]
 name = "polyxml"
-version = "0.23.3"
+version = "0.24.0"
 dependencies = [
  "criterion",
  "heck",
@@ -628,14 +628,14 @@ dependencies = [
 
 [[package]]
 name = "polyxml-c"
-version = "0.23.3"
+version = "0.24.0"
 dependencies = [
  "polyxml",
 ]
 
 [[package]]
 name = "polyxml-cli"
-version = "0.23.3"
+version = "0.24.0"
 dependencies = [
  "clap",
  "glob",
@@ -649,7 +649,7 @@ dependencies = [
 
 [[package]]
 name = "polyxml-js"
-version = "0.23.3"
+version = "0.24.0"
 dependencies = [
  "napi",
  "napi-build",
@@ -659,7 +659,7 @@ dependencies = [
 
 [[package]]
 name = "polyxml-python"
-version = "0.23.3"
+version = "0.24.0"
 dependencies = [
  "lexical-core",
  "polyxml",
@@ -669,7 +669,7 @@ dependencies = [
 
 [[package]]
 name = "polyxml-wasm"
-version = "0.23.3"
+version = "0.24.0"
 dependencies = [
  "polyxml",
  "quick-xml",

{polyxml-0.23.3 → polyxml-0.24.0}/Cargo.toml

@@ -3,7 +3,7 @@ resolver = "2"
 members = ["crates/polyxml-core", "crates/polyxml-python"]
 
 [workspace.package]
-version = "0.23.3"
+version = "0.24.0"
 edition = "2021"
 rust-version = "1.80"
 license = "MIT"

{polyxml-0.23.3 → polyxml-0.24.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: polyxml
-Version: 0.23.3
+Version: 0.24.0
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
@@ -31,12 +31,35 @@ Project-URL: Homepage, https://github.com/polyxml/PolyXML
 Project-URL: Issues, https://github.com/polyxml/PolyXML/issues
 Project-URL: Repository, https://github.com/polyxml/PolyXML
 
+<p align="center">
+  <a href="https://github.com/polyxml/PolyXML">
+    <img src="https://raw.githubusercontent.com/polyxml/PolyXML/main/docs/assets/brand/logo_polyxml_banner.png" alt="PolyXML" width="800">
+  </a>
+</p>
+
 # PolyXML Python Bindings
 
+<p align="center">
+  <a href="https://pypi.org/project/polyxml/"><img src="https://img.shields.io/pypi/v/polyxml.svg?logo=pypi&label=PyPI" alt="PyPI"></a>
+  <a href="https://www.python.org"><img src="https://img.shields.io/badge/Python-3.12%20%7C%203.13%20%7C%203.14%20%7C%203.15-3776AB.svg?logo=python&logoColor=white" alt="Python: 3.12+"></a>
+  <a href="https://polyxml.github.io/PolyXML/languages/python/"><img src="https://img.shields.io/badge/docs-zensical-blue.svg" alt="Documentation"></a>
+  <a href="https://opensource.org/licenses/MIT"><img src="https://img.shields.io/badge/License-MIT-blue.svg" alt="License: MIT"></a>
+</p>
+
 High-performance native XML data-binding engine for Python dataclasses and Pydantic models.
 
 Powered by `polyxml-core` written in Rust and PyO3 (`abi3-py312`).
 
+---
+
+## Installation
+
+```bash
+pip install polyxml
+```
+
+---
+
 ## Features
 
 - **⚡ Blazing Fast**: 16x faster deserialization and 38x faster serialization than standard Python tools.
@@ -44,6 +67,8 @@ Powered by `polyxml-core` written in Rust and PyO3 (`abi3-py312`).
 - **📦 Zero-GIL Binary Serialization**: Native `dumps_binary()` and `loads_binary()` using MessagePack (`msgspec`), up to 12.4x faster than pickle.
 - **🎯 Full Type Support**: Dataclasses and Pydantic v2 models with zero boilerplate.
 
+---
+
 ## Quickstart
 
 ```python

{polyxml-0.23.3/crates/polyxml-python → polyxml-0.24.0}/README.md

@@ -1,9 +1,32 @@
+<p align="center">
+  <a href="https://github.com/polyxml/PolyXML">
+    <img src="https://raw.githubusercontent.com/polyxml/PolyXML/main/docs/assets/brand/logo_polyxml_banner.png" alt="PolyXML" width="800">
+  </a>
+</p>
+
 # PolyXML Python Bindings
 
+<p align="center">
+  <a href="https://pypi.org/project/polyxml/"><img src="https://img.shields.io/pypi/v/polyxml.svg?logo=pypi&label=PyPI" alt="PyPI"></a>
+  <a href="https://www.python.org"><img src="https://img.shields.io/badge/Python-3.12%20%7C%203.13%20%7C%203.14%20%7C%203.15-3776AB.svg?logo=python&logoColor=white" alt="Python: 3.12+"></a>
+  <a href="https://polyxml.github.io/PolyXML/languages/python/"><img src="https://img.shields.io/badge/docs-zensical-blue.svg" alt="Documentation"></a>
+  <a href="https://opensource.org/licenses/MIT"><img src="https://img.shields.io/badge/License-MIT-blue.svg" alt="License: MIT"></a>
+</p>
+
 High-performance native XML data-binding engine for Python dataclasses and Pydantic models.
 
 Powered by `polyxml-core` written in Rust and PyO3 (`abi3-py312`).
 
+---
+
+## Installation
+
+```bash
+pip install polyxml
+```
+
+---
+
 ## Features
 
 - **⚡ Blazing Fast**: 16x faster deserialization and 38x faster serialization than standard Python tools.
@@ -11,6 +34,8 @@ Powered by `polyxml-core` written in Rust and PyO3 (`abi3-py312`).
 - **📦 Zero-GIL Binary Serialization**: Native `dumps_binary()` and `loads_binary()` using MessagePack (`msgspec`), up to 12.4x faster than pickle.
 - **🎯 Full Type Support**: Dataclasses and Pydantic v2 models with zero boilerplate.
 
+---
+
 ## Quickstart
 
 ```python

{polyxml-0.23.3 → polyxml-0.24.0}/crates/polyxml-core/README.md

@@ -1,8 +1,17 @@
+<p align="center">
+  <a href="https://github.com/polyxml/PolyXML">
+    <img src="https://raw.githubusercontent.com/polyxml/PolyXML/main/docs/assets/brand/logo_polyxml_banner.png" alt="PolyXML" width="800">
+  </a>
+</p>
+
 # polyxml
 
-[![Crates.io](https://img.shields.io/crates/v/polyxml.svg)](https://crates.io/crates/polyxml)
-[![Docs.rs](https://docs.rs/polyxml/badge.svg)](https://docs.rs/polyxml)
-[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://github.com/polyxml/PolyXML/blob/main/LICENSE)
+<p align="center">
+  <a href="https://crates.io/crates/polyxml"><img src="https://img.shields.io/crates/v/polyxml.svg?logo=rust&label=crates.io" alt="Crates.io"></a>
+  <a href="https://docs.rs/polyxml"><img src="https://docs.rs/polyxml/badge.svg" alt="Docs.rs"></a>
+  <a href="https://polyxml.github.io/PolyXML/"><img src="https://img.shields.io/badge/docs-zensical-blue.svg" alt="Documentation"></a>
+  <a href="https://opensource.org/licenses/MIT"><img src="https://img.shields.io/badge/License-MIT-blue.svg" alt="License: MIT"></a>
+</p>
 
 **PolyXML** is a high-performance streaming XML data-binding engine and polyglot schema compiler built in Rust. It serves as the foundational native core powering the `polyxml` CLI and language bindings across Python, C/C++, Java, TypeScript, Go, and C#.
 
@@ -23,19 +32,13 @@
 
 ## Installation
 
-Add `polyxml` to your `Cargo.toml`:
-
-```toml
-[dependencies]
-polyxml = "0.1.0"
-```
-
-Or run:
+Add `polyxml` to your Rust project:
 
 ```bash
 cargo add polyxml
 ```
 
+
 ---
 
 ## Quickstart

{polyxml-0.23.3 → polyxml-0.24.0}/crates/polyxml-core/src/codegen/mod.rs

@@ -18,7 +18,9 @@ pub use cpp::{CppBackend, CppCodegen, CppMode, CppOptions};
 pub use csharp::{CSharpCodegen, CSharpOptions, CSharpRecordKind};
 pub use go::{GoBackend, GoCodegen, GoOptions};
 pub use java::{JavaBackend, JavaCodegen, JavaOptions};
-pub use python::{PythonBackend, PythonCodegen, PythonOptions};
+pub use python::{
+    PythonAotCodegen, PythonAotCrate, PythonAotOptions, PythonBackend, PythonCodegen, PythonOptions,
+};
 pub use rust::{RustCodegen, RustOptions};
 pub use typescript::{TypeScriptBackend, TypeScriptCodegen, TypeScriptOptions};
 

polyxml-0.24.0/crates/polyxml-core/src/codegen/python/aot.rs

@@ -0,0 +1,295 @@
+//! Ahead-of-Time Python PyO3 native extension codegen.
+
+use std::collections::{BTreeSet, HashSet};
+use std::fmt::Write as FmtWrite;
+
+use heck::AsPascalCase;
+use serde::{Deserialize, Serialize};
+
+use crate::codegen::python::{to_field_identifier, PythonLanguageContext};
+use crate::codegen::rust::{RustCodegen, RustOptions};
+use crate::codegen::{
+    build_type_name_map, flatten_fields, lookup_type_name, set_type_name_map, LanguageContext,
+};
+use crate::ir::{EnumDef, FieldDef, QName, SchemaIR, StructDef, TypeDef, TypeRef};
+
+/// Options configuring Ahead-of-Time Python PyO3 extension compilation.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct PythonAotOptions {
+    pub module_name: String,
+    pub custom_header: Option<String>,
+}
+
+impl Default for PythonAotOptions {
+    fn default() -> Self {
+        Self {
+            module_name: "models".to_string(),
+            custom_header: None,
+        }
+    }
+}
+
+/// Represents the emitted multi-file PyO3 native extension crate.
+pub struct PythonAotCrate {
+    pub module_name: String,
+    pub cargo_toml: String,
+    pub pyproject_toml: String,
+    pub lib_rs: String,
+    pub pyi_stub: String,
+    pub readme: String,
+}
+
+/// Generator for native Python PyO3 C-extension crates.
+pub struct PythonAotCodegen {
+    options: PythonAotOptions,
+    context: PythonLanguageContext,
+}
+
+fn type_ident(q: &QName) -> String {
+    lookup_type_name(q, || AsPascalCase(&q.local).to_string())
+}
+
+impl PythonAotCodegen {
+    pub fn new(options: PythonAotOptions) -> Self {
+        Self {
+            options,
+            context: PythonLanguageContext,
+        }
+    }
+
+    /// Generates a turnkey, standalone PyO3 native extension crate.
+    pub fn generate_crate(&self, ir: &SchemaIR) -> PythonAotCrate {
+        let module_name = &self.options.module_name;
+
+        // 1. Cargo.toml
+        let cargo_toml = format!(
+            r#"[package]
+name = "{module_name}"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+name = "{module_name}"
+crate-type = ["cdylib"]
+
+[dependencies]
+pyo3 = {{ version = "0.29", features = ["abi3-py312", "extension-module"] }}
+serde = {{ version = "1.0", features = ["derive"] }}
+serde_json = "1.0"
+quick-xml = {{ version = "0.42", features = ["serialize"] }}
+"#
+        );
+
+        // 2. pyproject.toml
+        let pyproject_toml = format!(
+            r#"[build-system]
+requires = ["maturin>=1.5,<2.0"]
+build-backend = "maturin"
+
+[project]
+name = "{module_name}"
+version = "0.1.0"
+description = "PolyXML Python AOT native PyO3 extension module"
+requires-python = ">=3.12"
+dependencies = []
+
+[tool.maturin]
+module-name = "{module_name}"
+features = ["pyo3/extension-module"]
+"#
+        );
+
+        // 3. README.md
+        let readme = format!(
+            r#"# {module_name} (PolyXML Python AOT Extension)
+
+High-performance native Python extension module generated by PolyXML, compiled with PyO3 and Rust.
+
+## Building and Installing
+
+```bash
+# In active virtual environment:
+maturin develop --release
+
+# Or build wheel:
+maturin build --release
+```
+
+## Quick Start
+
+```python
+import {module_name}
+
+# Create instance
+obj = {module_name}.<ModelName>()
+
+# Serialize / Deserialize XML
+xml_data = obj.to_xml()
+restored = {module_name}.<ModelName>.from_xml(xml_data)
+
+# Serialize / Deserialize JSON
+json_data = obj.to_json()
+restored_json = {module_name}.<ModelName>.from_json(json_data)
+```
+"#
+        );
+
+        // 4. Rust source (src/lib.rs)
+        let rust_opts = RustOptions {
+            zero_copy: false,
+            derive_serde: true,
+            derive_default: true,
+            emit_polyxml_attrs: false,
+            emit_root_aliases: true,
+            emit_codecs: true,
+            emit_rkyv: false,
+            phf: false,
+            pyo3: true,
+            pyo3_module_name: Some(module_name.clone()),
+            custom_header: self.options.custom_header.clone(),
+        };
+        let rust_codegen = RustCodegen::new(rust_opts);
+        let lib_rs = rust_codegen.generate_module(ir);
+
+        // 5. Python Type Stub (.pyi)
+        let pyi_stub = self.generate_pyi(ir);
+
+        PythonAotCrate {
+            module_name: module_name.clone(),
+            cargo_toml,
+            pyproject_toml,
+            lib_rs,
+            pyi_stub,
+            readme,
+        }
+    }
+
+    /// Generates PEP-561 compliant `.pyi` type stubs with docstrings and type hints.
+    pub fn generate_pyi(&self, ir: &SchemaIR) -> String {
+        set_type_name_map(build_type_name_map(ir, |local| {
+            AsPascalCase(local).to_string()
+        }));
+
+        let mut out = String::new();
+        out.push_str("# @generated by PolyXML Compiler (Python AOT PyO3 Extension)\n");
+        out.push_str("from __future__ import annotations\n");
+        out.push_str("import enum\n");
+        out.push_str("import typing\n\n");
+
+        for td in ir.types.values() {
+            match td {
+                TypeDef::Enum(e) => self.emit_pyi_enum(&mut out, e),
+                TypeDef::Struct(s) => self.emit_pyi_struct(&mut out, s, ir),
+                TypeDef::Simple(s) => {
+                    let type_name = type_ident(&s.qname);
+                    let base_type = self.context.map_type_ref(&s.base_type);
+                    let _ = writeln!(out, "type {} = {}\n", type_name, base_type);
+                }
+                TypeDef::Union(_) => {}
+            }
+        }
+
+        // Emit root element aliases
+        let mut declared_names = BTreeSet::new();
+        for td in ir.types.values() {
+            declared_names.insert(type_ident(td.qname()));
+        }
+        for element in ir.elements.values() {
+            let el_name = AsPascalCase(&element.qname.local).to_string();
+            if !declared_names.contains(&el_name) {
+                let target_type = self.context.map_type_ref(&element.type_ref);
+                if el_name != target_type {
+                    let _ = writeln!(out, "type {} = {}", el_name, target_type);
+                    declared_names.insert(el_name);
+                }
+            }
+        }
+
+        out
+    }
+
+    fn emit_pyi_enum(&self, out: &mut String, e: &EnumDef) {
+        let enum_name = type_ident(&e.qname);
+        if let Some(ref doc) = e.documentation {
+            let _ = writeln!(out, "\"\"\"{}\"\"\"", doc.trim());
+        }
+        let _ = writeln!(out, "class {}(enum.IntEnum):", enum_name);
+        for v in &e.variants {
+            let var_name = AsPascalCase(&v.name).to_string();
+            let _ = writeln!(out, "    {}: int", var_name);
+        }
+        out.push('\n');
+    }
+
+    fn emit_pyi_struct(&self, out: &mut String, s: &StructDef, ir: &SchemaIR) {
+        let struct_name = type_ident(&s.qname);
+        let _ = writeln!(out, "class {}:", struct_name);
+        if let Some(ref doc) = s.documentation {
+            let _ = writeln!(out, "    \"\"\"{}\"\"\"", doc.trim());
+        }
+
+        let fields = flatten_fields(s, ir);
+        let mut seen_fields = HashSet::new();
+
+        // Field signatures for type checking
+        for field in &fields {
+            let field_name = self.unique_py_field_name(&field.name, &mut seen_fields);
+            let py_type = self.field_python_type(field);
+            let _ = writeln!(out, "    {}: {}", field_name, py_type);
+        }
+
+        // __init__ constructor
+        seen_fields.clear();
+        out.push_str("\n    def __init__(\n        self,\n");
+        for field in &fields {
+            let field_name = self.unique_py_field_name(&field.name, &mut seen_fields);
+            let py_type = self.field_python_type(field);
+            let _ = writeln!(out, "        {}: {} | None = None,", field_name, py_type);
+        }
+        out.push_str("    ) -> None: ...\n\n");
+
+        // Codecs
+        out.push_str("    def to_xml(self) -> str: ...\n");
+        let _ = writeln!(
+            out,
+            "    @staticmethod\n    def from_xml(xml: str) -> {}: ...",
+            struct_name
+        );
+        out.push_str("    def to_json(self) -> str: ...\n");
+        let _ = writeln!(
+            out,
+            "    @staticmethod\n    def from_json(json_str: str) -> {}: ...\n",
+            struct_name
+        );
+    }
+
+    fn unique_py_field_name(&self, name: &str, seen: &mut HashSet<String>) -> String {
+        let base = to_field_identifier(name);
+        let mut candidate = base.clone();
+        let mut counter = 1;
+        while seen.contains(&candidate) {
+            counter += 1;
+            candidate = format!("{}_{}", base, counter);
+        }
+        seen.insert(candidate.clone());
+        candidate
+    }
+
+    fn field_python_type(&self, field: &FieldDef) -> String {
+        let is_list = field.cardinality.is_list() || field.type_ref.is_list();
+        let is_optional = field.cardinality.is_optional() || field.nillable;
+        let inner_ref = match &field.type_ref {
+            TypeRef::List(inner) => inner.as_ref(),
+            other => other,
+        };
+        let inner_type = self.context.map_type_ref(inner_ref);
+
+        if is_list {
+            format!("list[{}]", inner_type)
+        } else if is_optional {
+            format!("{} | None", inner_type)
+        } else {
+            inner_type
+        }
+    }
+}

{polyxml-0.23.3 → polyxml-0.24.0}/crates/polyxml-core/src/codegen/python/mod.rs

@@ -28,12 +28,16 @@ const PATTERN_VALIDATOR_HELPER: &str = r#"def _polyxml_patterns(*patterns: str):
     return _validate
 "#;
 
+pub mod aot;
+pub use aot::{PythonAotCodegen, PythonAotCrate, PythonAotOptions};
+
 /// Target backend for Python code emission.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Serialize, Deserialize)]
 pub enum PythonBackend {
     #[default]
     Dataclass,
     Pydantic,
+    Aot,
 }
 
 impl PythonBackend {
@@ -41,6 +45,7 @@ impl PythonBackend {
         match s.to_lowercase().trim() {
             "dataclass" | "dataclasses" | "std" | "stdlib" => Some(Self::Dataclass),
             "pydantic" | "pydantic_v2" | "pydantic-v2" | "pydantic2" => Some(Self::Pydantic),
+            "aot" | "native" | "pyo3" => Some(Self::Aot),
             _ => None,
         }
     }
@@ -223,6 +228,14 @@ impl PythonCodegen {
     }
 
     pub fn generate_module(&self, ir: &SchemaIR) -> String {
+        if self.options.backend == PythonBackend::Aot {
+            let aot = PythonAotCodegen::new(PythonAotOptions {
+                module_name: "models".to_string(),
+                custom_header: self.options.custom_header.clone(),
+            });
+            return aot.generate_crate(ir).lib_rs;
+        }
+
         set_type_name_map(build_type_name_map(ir, |local| {
             AsPascalCase(local).to_string()
         }));
@@ -517,7 +530,7 @@ impl PythonCodegen {
             .map(type_ident);
 
         match self.options.backend {
-            PythonBackend::Dataclass => {
+            PythonBackend::Dataclass | PythonBackend::Aot => {
                 let slots_arg = if self.options.slots {
                     "slots=True"
                 } else {
@@ -657,7 +670,7 @@ impl PythonCodegen {
         let meta_dict = self.build_field_metadata(field);
 
         let (field_type, field_call) = match self.options.backend {
-            PythonBackend::Dataclass => {
+            PythonBackend::Dataclass | PythonBackend::Aot => {
                 self.format_dataclass_field(field, is_list, &inner_type, &meta_dict)
             }
             PythonBackend::Pydantic => {