pysof 0.1.32__tar.gz → 0.1.42__tar.gz

pysof-0.1.42/Cargo.toml

@@ -0,0 +1,40 @@
+[package]
+name = "pysof"
+version.workspace = true
+edition = "2024"
+description = "Python bindings for helios-sof using PyO3"
+license.workspace = true
+authors.workspace = true
+repository.workspace = true
+homepage = "https://github.com/HeliosSoftware/hfs/tree/main/crates/pysof"
+rust-version.workspace = true
+keywords = ["helios-software", "hl7", "fhir", "helios-fhir-server", "sql-on-fhir"]
+
+# PyO3 extension metadata
+[lib]
+name = "pysof"
+crate-type = ["cdylib"]
+
+[dependencies]
+pyo3 = { version = ">=0.27", features = ["extension-module", "generate-import-lib"] }
+helios-sof = { path = "../sof", version = "0.1.42" }
+helios-fhir = { path = "../fhir", version = "0.1.42" }
+serde = { workspace = true }
+serde_json = { workspace = true }
+chrono = { version = "0.4", features = ["serde"] }
+pythonize = "0.27"
+csv = "1.3"
+
+[features]
+default = ["R4"]
+R4 = ["helios-sof/R4", "helios-fhir/R4"]
+R4B = ["helios-sof/R4B", "helios-fhir/R4B"]
+R5 = ["helios-sof/R5", "helios-fhir/R5"]
+R6 = ["helios-sof/R6", "helios-fhir/R6"]
+
+# Vendor OpenSSL when cross-compiling for Linux ARM64
+[target.'cfg(all(target_arch = "aarch64", target_os = "linux"))'.dependencies]
+openssl = { version = "0.10", features = ["vendored"] }
+
+[build-dependencies]
+pyo3-build-config = "0.27"

{pysof-0.1.32 → pysof-0.1.42}/PKG-INFO

@@ -1,11 +1,12 @@
 Metadata-Version: 2.4
 Name: pysof
-Version: 0.1.32
+Version: 0.1.42
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Development Status :: 4 - Beta
@@ -15,6 +16,7 @@ Classifier: Topic :: Scientific/Engineering :: Medical Science Apps.
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Summary: Python wrapper for the Helios Software SOF (SQL on FHIR) toolkit.
 Keywords: SQL on FHIR,FHIR,healthcare,sof,Helios Software
+Home-Page: https://github.com/HeliosSoftware/hfs/tree/main/crates/pysof
 Author-email: Helios Software <team@heliossoftware.com>
 License: MIT
 Requires-Python: >=3.10
@@ -77,7 +79,7 @@ pip install pysof
 - **Linux**: x86_64 (glibc and musl)
 - **Windows**: x86_64 (MSVC)
 - **macOS**: AArch64 (Apple Silicon)
-- **Python**: 3.10, 3.11, 3.12, 3.13
+- **Python**: 3.10, 3.11, 3.12, 3.13, 3.14
 
 ### From GitHub Releases
 
@@ -346,7 +348,7 @@ Use `pysof.get_supported_fhir_versions()` to check available versions in your bu
 
 ### Requirements
 
-- Python 3.10 or later (3.10, 3.11, 3.12, 3.13 supported)
+- Python 3.10 or later (3.10, 3.11, 3.12, 3.13, 3.14 supported)
 - uv (package and environment manager)
 - Rust toolchain (for building from source)
 
@@ -378,7 +380,7 @@ For Python development, it's recommended to use `maturin` via `uv`:
 cd crates/pysof
 
 # Create a venv with your preferred Python version (3.10+)
-uv venv --python 3.11  # or 3.10, 3.12, 3.13
+uv venv --python 3.11  # or 3.10, 3.12, 3.13, 3.14
 
 # Install the project dev dependencies
 uv sync --group dev

{pysof-0.1.32/crates/pysof → pysof-0.1.42}/README.md

@@ -50,7 +50,7 @@ pip install pysof
 - **Linux**: x86_64 (glibc and musl)
 - **Windows**: x86_64 (MSVC)
 - **macOS**: AArch64 (Apple Silicon)
-- **Python**: 3.10, 3.11, 3.12, 3.13
+- **Python**: 3.10, 3.11, 3.12, 3.13, 3.14
 
 ### From GitHub Releases
 
@@ -319,7 +319,7 @@ Use `pysof.get_supported_fhir_versions()` to check available versions in your bu
 
 ### Requirements
 
-- Python 3.10 or later (3.10, 3.11, 3.12, 3.13 supported)
+- Python 3.10 or later (3.10, 3.11, 3.12, 3.13, 3.14 supported)
 - uv (package and environment manager)
 - Rust toolchain (for building from source)
 
@@ -351,7 +351,7 @@ For Python development, it's recommended to use `maturin` via `uv`:
 cd crates/pysof
 
 # Create a venv with your preferred Python version (3.10+)
-uv venv --python 3.11  # or 3.10, 3.12, 3.13
+uv venv --python 3.11  # or 3.10, 3.12, 3.13, 3.14
 
 # Install the project dev dependencies
 uv sync --group dev

{pysof-0.1.32 → pysof-0.1.42}/crates/fhir/Cargo.toml

@@ -8,6 +8,7 @@ authors.workspace = true
 repository.workspace = true
 homepage = "https://github.com/HeliosSoftware/hfs/tree/main/crates/fhir"
 readme = "README.md"
+keywords = ["helios-software", "hl7", "fhir", "helios-fhir-server", "healthcare"]
 exclude = ["tests/data/**"]
 
 [features]
@@ -17,13 +18,15 @@ R4B = []
 R5 = []
 R6 = []
 skip-r6-download = []
+xml = ["helios-serde-support/xml"]
 
 [dependencies]
 serde = { workspace = true }
 serde_json = { workspace = true, features = ["raw_value"] }
 clap = { version = "4.0", features = ["derive"] }
-helios-fhir-macro = { path = "../fhir-macro", version = "0.1.32" }
-helios-fhirpath-support = { path = "../fhirpath-support", version = "0.1.32" }
+helios-fhir-macro = { path = "../fhir-macro", version = "0.1.42" }
+helios-serde-support = { path = "../serde-support", version = "0.1.42" }
+helios-fhirpath-support = { path = "../fhirpath-support", version = "0.1.42" }
 time = "0.3"
 chrono = { workspace = true }
 # Re-add serde-with-arbitrary-precision, keep macros
@@ -39,5 +42,3 @@ zip = "0.6"
 [package.metadata.docs.rs]
 all-features = true
 rustdoc-args = ["--cfg", "docsrs"]
-
-

{pysof-0.1.32 → pysof-0.1.42}/crates/fhir/build.rs

@@ -18,16 +18,34 @@ fn main() {
         return;
     }
 
-    println!("cargo:warning=Downloading R6 test data from HL7 build server");
-
-    let resources_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("tests/data/R6");
+    let json_resources_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("tests/data/json/R6");
+    let xml_resources_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("tests/data/xml/R6");
+
+    // Create the resources directories if they don't exist
+    fs::create_dir_all(&json_resources_dir).expect("Failed to create JSON resources directory");
+    fs::create_dir_all(&xml_resources_dir).expect("Failed to create XML resources directory");
+
+    // Check if test data is recent (skip download if less than 24 hours old)
+    // Use a marker file to track when we last downloaded
+    let marker_path = json_resources_dir.join(".download_marker");
+    if let Ok(metadata) = fs::metadata(&marker_path) {
+        if let Ok(modified) = metadata.modified() {
+            if let Ok(duration) = modified.elapsed() {
+                if duration.as_secs() < 86400 {
+                    println!("cargo:warning=R6 test data is recent, skipping download");
+                    return;
+                }
+            }
+        }
+    }
 
-    // Create the resources directory if it doesn't exist
-    fs::create_dir_all(&resources_dir).expect("Failed to create resources directory");
+    println!("cargo:warning=Downloading R6 test data from HL7 build server");
 
-    let url = "https://build.fhir.org/examples-json.zip";
+    let json_url = "https://build.fhir.org/examples-json.zip";
+    let xml_url = "https://build.fhir.org/examples.zip";
 
-    let output_path = resources_dir.join("examples.json.zip");
+    let json_output_path = json_resources_dir.join("examples.json.zip");
+    let xml_output_path = xml_resources_dir.join("examples.xml.zip");
 
     println!("Downloading test data ...");
 
@@ -40,12 +58,15 @@ fn main() {
 
     // Try downloading with retries
     const MAX_RETRIES: u32 = 3;
+
+    // Download JSON examples
+    println!("Downloading JSON examples...");
     let mut last_error = None;
 
     for attempt in 1..=MAX_RETRIES {
-        println!("Download attempt {} of {}", attempt, MAX_RETRIES);
+        println!("JSON download attempt {} of {}", attempt, MAX_RETRIES);
 
-        match download_with_retry(&client, url, &output_path) {
+        match download_with_retry(&client, json_url, &json_output_path) {
             Ok(bytes) => {
                 println!("Downloaded {} bytes", bytes);
                 last_error = None;
@@ -66,13 +87,59 @@ fn main() {
 
     if let Some(error) = last_error {
         panic!(
-            "Failed to download file after {} attempts: {}",
+            "Failed to download JSON file after {} attempts: {}",
             MAX_RETRIES, error
         );
     }
 
+    // Extract JSON examples
+    extract_and_clean(&json_output_path, &json_resources_dir, "examples.json.zip");
+
+    // Download XML examples
+    println!("Downloading XML examples...");
+    last_error = None;
+
+    for attempt in 1..=MAX_RETRIES {
+        println!("XML download attempt {} of {}", attempt, MAX_RETRIES);
+
+        match download_with_retry(&client, xml_url, &xml_output_path) {
+            Ok(bytes) => {
+                println!("Downloaded {} bytes", bytes);
+                last_error = None;
+                break;
+            }
+            Err(e) => {
+                println!("Attempt {} failed: {}", attempt, e);
+                last_error = Some(e);
+
+                if attempt < MAX_RETRIES {
+                    let wait_time = Duration::from_secs(5 * attempt as u64);
+                    println!("Waiting {:?} before retry...", wait_time);
+                    thread::sleep(wait_time);
+                }
+            }
+        }
+    }
+
+    if let Some(error) = last_error {
+        panic!(
+            "Failed to download XML file after {} attempts: {}",
+            MAX_RETRIES, error
+        );
+    }
+
+    // Extract XML examples
+    extract_and_clean(&xml_output_path, &xml_resources_dir, "examples.xml.zip");
+
+    // Write marker file to track download time
+    fs::write(&marker_path, "").expect("Failed to write download marker");
+
+    println!("FHIR test data downloaded successfully");
+}
+
+fn extract_and_clean(zip_path: &PathBuf, resources_dir: &PathBuf, zip_filename: &str) {
     // Verify and extract the downloaded file
-    let file = fs::File::open(&output_path).expect("Failed to open downloaded file");
+    let file = fs::File::open(zip_path).expect("Failed to open downloaded file");
     let metadata = file.metadata().expect("Failed to get file metadata");
     println!("File size on disk: {} bytes", metadata.len());
 
@@ -84,12 +151,12 @@ fn main() {
 
     // Clean out the resources directory before extracting (removes old files that may no longer exist in the zip)
     println!("cargo:warning=Cleaning resources directory before extraction...");
-    for entry in fs::read_dir(&resources_dir).unwrap() {
+    for entry in fs::read_dir(resources_dir).unwrap() {
         let entry = entry.unwrap();
         let path = entry.path();
 
         // Skip the zip file itself
-        if path.file_name() == Some(std::ffi::OsStr::new("examples.json.zip")) {
+        if path.file_name() == Some(std::ffi::OsStr::new(zip_filename)) {
             continue;
         }
 
@@ -122,9 +189,7 @@ fn main() {
     }
 
     // Delete the zip file after extraction
-    fs::remove_file(output_path).expect("Failed to delete zip file");
-
-    println!("FHIR test data downloaded successfully");
+    fs::remove_file(zip_path).expect("Failed to delete zip file");
 }
 
 fn download_with_retry(

{pysof-0.1.32 → pysof-0.1.42}/crates/fhir/src/lib.rs

@@ -43,6 +43,9 @@
 
 use chrono::{DateTime as ChronoDateTime, NaiveDate, NaiveTime, Utc};
 use helios_fhirpath_support::{EvaluationResult, IntoEvaluationResult, TypeInfoResult};
+#[cfg(feature = "xml")]
+use helios_serde_support::SingleOrVec;
+
 use rust_decimal::Decimal;
 use serde::{
     Deserialize, Serialize,
@@ -1432,6 +1435,8 @@ pub mod parameters;
 // Re-export commonly used types from parameters module
 pub use parameters::{ParameterValueAccessor, VersionIndependentParameters};
 
+// Internal helpers used by the derive macro; not part of the public API
+#[doc(hidden)]
 /// Multi-version FHIR resource container supporting version-agnostic operations.
 ///
 /// This enum provides a unified interface for working with FHIR resources across
@@ -1471,7 +1476,7 @@ pub use parameters::{ParameterValueAccessor, VersionIndependentParameters};
 ///     };
 ///
 ///     // Wrap in version-agnostic container
-///     let resource = FhirResource::R4(Box::new(helios_fhir::r4::Resource::Patient(patient)));
+///     let resource = FhirResource::R4(Box::new(helios_fhir::r4::Resource::Patient(Box::new(patient))));
 ///     assert_eq!(resource.version(), FhirVersion::R4);
 /// }
 /// ```
@@ -1618,7 +1623,7 @@ impl FhirResource {
 ///     version: FhirVersion,
 /// }
 /// ```
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
 pub enum FhirVersion {
     /// FHIR 4.0.1 (normative) - The current normative version
     #[cfg(feature = "R4")]
@@ -1674,6 +1679,155 @@ impl FhirVersion {
             FhirVersion::R6 => "R6",
         }
     }
+
+    /// Parse from MIME-type parameter value (e.g., "4.0", "5.0").
+    ///
+    /// Per FHIR spec: <https://hl7.org/fhir/http.html#version-parameter>
+    ///
+    /// # Arguments
+    ///
+    /// * `value` - The MIME-type parameter value (e.g., "4.0", "4.3", "5.0", "6.0")
+    ///
+    /// # Returns
+    ///
+    /// The corresponding `FhirVersion` if the value matches an enabled version,
+    /// or `None` if not recognized or the version feature is not enabled.
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// use helios_fhir::FhirVersion;
+    ///
+    /// # #[cfg(feature = "R4")]
+    /// assert_eq!(FhirVersion::from_mime_param("4.0"), Some(FhirVersion::R4));
+    /// # #[cfg(feature = "R5")]
+    /// assert_eq!(FhirVersion::from_mime_param("5.0"), Some(FhirVersion::R5));
+    /// assert_eq!(FhirVersion::from_mime_param("invalid"), None);
+    /// ```
+    pub fn from_mime_param(value: &str) -> Option<Self> {
+        match value.trim() {
+            #[cfg(feature = "R4")]
+            "4.0" => Some(FhirVersion::R4),
+            #[cfg(feature = "R4B")]
+            "4.3" => Some(FhirVersion::R4B),
+            #[cfg(feature = "R5")]
+            "5.0" => Some(FhirVersion::R5),
+            #[cfg(feature = "R6")]
+            "6.0" => Some(FhirVersion::R6),
+            _ => None,
+        }
+    }
+
+    /// Returns the MIME-type parameter value for this version.
+    ///
+    /// This value is used in Content-Type and Accept headers per FHIR spec.
+    /// Example: `application/fhir+json; fhirVersion=4.0`
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// use helios_fhir::FhirVersion;
+    ///
+    /// # #[cfg(feature = "R4")]
+    /// assert_eq!(FhirVersion::R4.as_mime_param(), "4.0");
+    /// # #[cfg(feature = "R5")]
+    /// assert_eq!(FhirVersion::R5.as_mime_param(), "5.0");
+    /// ```
+    pub fn as_mime_param(&self) -> &'static str {
+        match self {
+            #[cfg(feature = "R4")]
+            FhirVersion::R4 => "4.0",
+            #[cfg(feature = "R4B")]
+            FhirVersion::R4B => "4.3",
+            #[cfg(feature = "R5")]
+            FhirVersion::R5 => "5.0",
+            #[cfg(feature = "R6")]
+            FhirVersion::R6 => "6.0",
+        }
+    }
+
+    /// Returns the full version string (e.g., "4.0.1", "5.0.0").
+    ///
+    /// This is the complete version identifier used in CapabilityStatement.fhirVersion.
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// use helios_fhir::FhirVersion;
+    ///
+    /// # #[cfg(feature = "R4")]
+    /// assert_eq!(FhirVersion::R4.full_version(), "4.0.1");
+    /// # #[cfg(feature = "R5")]
+    /// assert_eq!(FhirVersion::R5.full_version(), "5.0.0");
+    /// ```
+    pub fn full_version(&self) -> &'static str {
+        match self {
+            #[cfg(feature = "R4")]
+            FhirVersion::R4 => "4.0.1",
+            #[cfg(feature = "R4B")]
+            FhirVersion::R4B => "4.3.0",
+            #[cfg(feature = "R5")]
+            FhirVersion::R5 => "5.0.0",
+            #[cfg(feature = "R6")]
+            FhirVersion::R6 => "6.0.0",
+        }
+    }
+
+    /// Parse from database storage string.
+    ///
+    /// Accepts both MIME format ("4.0") and short format ("R4") for flexibility.
+    /// This is useful when loading version information from the database.
+    ///
+    /// # Arguments
+    ///
+    /// * `value` - The storage value (e.g., "4.0", "R4", "r4")
+    ///
+    /// # Returns
+    ///
+    /// The corresponding `FhirVersion` if recognized, or `None` otherwise.
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// use helios_fhir::FhirVersion;
+    ///
+    /// # #[cfg(feature = "R4")]
+    /// {
+    /// assert_eq!(FhirVersion::from_storage("4.0"), Some(FhirVersion::R4));
+    /// assert_eq!(FhirVersion::from_storage("R4"), Some(FhirVersion::R4));
+    /// assert_eq!(FhirVersion::from_storage("r4"), Some(FhirVersion::R4));
+    /// }
+    /// ```
+    pub fn from_storage(value: &str) -> Option<Self> {
+        // Try MIME format first
+        Self::from_mime_param(value).or_else(|| match value.to_uppercase().as_str() {
+            #[cfg(feature = "R4")]
+            "R4" => Some(FhirVersion::R4),
+            #[cfg(feature = "R4B")]
+            "R4B" => Some(FhirVersion::R4B),
+            #[cfg(feature = "R5")]
+            "R5" => Some(FhirVersion::R5),
+            #[cfg(feature = "R6")]
+            "R6" => Some(FhirVersion::R6),
+            _ => None,
+        })
+    }
+
+    /// Returns all enabled FHIR versions.
+    ///
+    /// This is useful for listing supported versions (e.g., in `$versions` operation).
+    pub fn enabled_versions() -> &'static [FhirVersion] {
+        &[
+            #[cfg(feature = "R4")]
+            FhirVersion::R4,
+            #[cfg(feature = "R4B")]
+            FhirVersion::R4B,
+            #[cfg(feature = "R5")]
+            FhirVersion::R5,
+            #[cfg(feature = "R6")]
+            FhirVersion::R6,
+        ]
+    }
 }
 
 /// Implements `Display` trait for user-friendly output formatting.
@@ -1843,7 +1997,15 @@ where
                     if extension.is_some() {
                         return Err(de::Error::duplicate_field("extension"));
                     }
-                    extension = Some(map.next_value()?);
+                    #[cfg(feature = "xml")]
+                    {
+                        let single_or_vec: SingleOrVec<E> = map.next_value()?;
+                        extension = Some(single_or_vec.into());
+                    }
+                    #[cfg(not(feature = "xml"))]
+                    {
+                        extension = Some(map.next_value()?);
+                    }
                 }
                 "value" => {
                     if value.is_some() {
@@ -1928,10 +2090,11 @@ pub struct Element<V, E> {
 }
 
 impl<V, E> Element<V, E> {
-    /// Returns `true` if no value, id, or extensions are present.
-    #[inline]
+    /// Returns true when no value, id, or extensions are present.
     pub fn is_empty(&self) -> bool {
-        self.value.is_none() && self.id.is_none() && self.extension.is_none()
+        self.value.is_none()
+            && self.id.is_none()
+            && self.extension.as_ref().is_none_or(|ext| ext.is_empty())
     }
 }
 
@@ -2422,12 +2585,6 @@ impl<E> DecimalElement<E> {
             value: Some(precise_value),
         }
     }
-
-    /// Returns `true` if the element has no value, id, or extensions.
-    #[inline]
-    pub fn is_empty(&self) -> bool {
-        self.value.is_none() && self.id.is_none() && self.extension.is_none()
-    }
 }
 
 // Custom Deserialize for DecimalElement<E> using intermediate Value
@@ -2501,8 +2658,17 @@ where
                             if extension.is_some() {
                                 return Err(de::Error::duplicate_field("extension"));
                             }
-                            // Deserialize extension directly from its Value
-                            extension = Deserialize::deserialize(v).map_err(de::Error::custom)?;
+                            #[cfg(feature = "xml")]
+                            {
+                                let single_or_vec: SingleOrVec<E> =
+                                    Deserialize::deserialize(v).map_err(de::Error::custom)?;
+                                extension = Some(single_or_vec.into());
+                            }
+                            #[cfg(not(feature = "xml"))]
+                            {
+                                extension =
+                                    Deserialize::deserialize(v).map_err(de::Error::custom)?;
+                            }
                         }
                         "value" => {
                             if value.is_some() {

{pysof-0.1.32 → pysof-0.1.42}/crates/fhir/src/parameters.rs

@@ -25,27 +25,16 @@ use serde::{Deserialize, Serialize};
 ///
 /// ```rust
 /// use helios_fhir::VersionIndependentParameters;
-/// # #[cfg(feature = "R4")]
-/// use helios_fhir::r4::Parameters;
 ///
 /// # #[cfg(feature = "R4")]
 /// # {
-/// // Parse from JSON
-/// let json = r#"{
-///     "resourceType": "Parameters",
-///     "parameter": [{
-///         "name": "expression",
-///         "valueString": "Patient.name"
-///     }]
-/// }"#;
-///
-/// let params: Parameters = serde_json::from_str(json)?;
+/// // Create Parameters directly (avoids stack overflow on Windows from deep serde recursion)
+/// let params = helios_fhir::r4::Parameters::default();
 /// let version_independent = VersionIndependentParameters::R4(params);
 ///
 /// // Check version
 /// assert_eq!(version_independent.version(), helios_fhir::FhirVersion::R4);
 /// # }
-/// # Ok::<(), Box<dyn std::error::Error>>(())
 /// ```
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(untagged)]