ofd-validator 0.4.0__tar.gz → 0.5.0__tar.gz

{ofd_validator-0.4.0 → ofd_validator-0.5.0}/Cargo.lock

@@ -805,7 +805,7 @@ dependencies = [
 
 [[package]]
 name = "ofd-validator-core"
-version = "0.4.0"
+version = "0.5.0"
 dependencies = [
  "image",
  "jsonschema",
@@ -818,7 +818,7 @@ dependencies = [
 
 [[package]]
 name = "ofd-validator-js"
-version = "0.4.0"
+version = "0.5.0"
 dependencies = [
  "napi",
  "napi-build",
@@ -831,7 +831,7 @@ dependencies = [
 
 [[package]]
 name = "ofd-validator-python"
-version = "0.4.0"
+version = "0.5.0"
 dependencies = [
  "ofd-validator-core",
  "pyo3",

{ofd_validator-0.4.0 → ofd_validator-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ofd-validator
-Version: 0.4.0
+Version: 0.5.0
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License

{ofd_validator-0.4.0 → ofd_validator-0.5.0}/crates/ofd-validator-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ofd-validator-core"
-version = "0.4.0"
+version = "0.5.0"
 edition = "2021"
 authors = ["Open Filament Collective"]
 license = "MIT"

{ofd_validator-0.4.0 → ofd_validator-0.5.0}/crates/ofd-validator-python/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ofd-validator-python"
-version = "0.4.0"
+version = "0.5.0"
 edition = "2021"
 authors = ["Open Filament Collective"]
 license = "MIT"

ofd_validator-0.5.0/crates/ofd-validator-python/src/orchestrator.rs

@@ -0,0 +1,171 @@
+use std::path::PathBuf;
+
+use pyo3::prelude::*;
+use rayon::ThreadPoolBuilder;
+
+use ofd_validator_core as core;
+
+use crate::types::ValidationResult;
+use crate::util::log_step;
+
+/// Run the closure on a custom Rayon thread pool when `max_workers` is set,
+/// otherwise use the global pool (default Rayon behaviour).
+fn with_thread_pool<F, R>(max_workers: Option<usize>, f: F) -> R
+where
+    F: FnOnce() -> R + Send,
+    R: Send,
+{
+    match max_workers {
+        Some(n) if n > 0 => {
+            let pool = ThreadPoolBuilder::new()
+                .num_threads(n)
+                .build()
+                .expect("failed to build Rayon thread pool");
+            pool.install(f)
+        }
+        _ => f(),
+    }
+}
+
+#[pyfunction]
+#[pyo3(signature = (data_dir, stores_dir, schemas_dir=None, max_workers=None))]
+pub fn validate_all(
+    py: Python<'_>,
+    data_dir: &str,
+    stores_dir: &str,
+    schemas_dir: Option<&str>,
+    max_workers: Option<usize>,
+) -> ValidationResult {
+    let data_dir = PathBuf::from(data_dir);
+    let stores_dir = PathBuf::from(stores_dir);
+    let schemas_dir = PathBuf::from(schemas_dir.unwrap_or("schemas"));
+
+    py.allow_threads(|| {
+        with_thread_pool(max_workers, || {
+            log_step("Loading dataset", None);
+            let dataset = core::DataSet::from_directories(&data_dir, &stores_dir, &schemas_dir);
+
+            log_step("Checking required files", None);
+            log_step("Validating JSON schemas", Some(dataset.json_entries.len()));
+            log_step("Validating logos", Some(dataset.logo_entries.len()));
+            log_step("Validating folder names", Some(dataset.folder_entries.len()));
+            log_step("Validating store IDs", None);
+            log_step("Validating GTIN/EAN codes", None);
+
+            core::validate_dataset(&dataset).into()
+        })
+    })
+}
+
+#[pyfunction]
+#[pyo3(signature = (data_dir, stores_dir, schemas_dir=None, max_workers=None))]
+pub fn validate_json_files(
+    py: Python<'_>,
+    data_dir: &str,
+    stores_dir: &str,
+    schemas_dir: Option<&str>,
+    max_workers: Option<usize>,
+) -> ValidationResult {
+    let data_dir = PathBuf::from(data_dir);
+    let stores_dir = PathBuf::from(stores_dir);
+    let schemas_dir = PathBuf::from(schemas_dir.unwrap_or("schemas"));
+
+    py.allow_threads(|| {
+        with_thread_pool(max_workers, || {
+            let dataset = core::DataSet::from_directories(&data_dir, &stores_dir, &schemas_dir);
+            log_step("Validating JSON schemas", Some(dataset.json_entries.len()));
+
+            use rayon::prelude::*;
+            let results: Vec<core::ValidationResult> = dataset.json_entries
+                .par_iter()
+                .map(|(path, schema_name, data)| {
+                    core::validators::validate_json(data, schema_name, &dataset.schema_cache, Some(path))
+                })
+                .collect();
+
+            let mut result = core::ValidationResult::default();
+            for r in results {
+                result.merge_from(&r);
+            }
+            result.into()
+        })
+    })
+}
+
+#[pyfunction]
+#[pyo3(signature = (data_dir, stores_dir, max_workers=None))]
+pub fn validate_logo_files(
+    py: Python<'_>,
+    data_dir: &str,
+    stores_dir: &str,
+    max_workers: Option<usize>,
+) -> ValidationResult {
+    let data_dir = PathBuf::from(data_dir);
+    let stores_dir = PathBuf::from(stores_dir);
+    let schemas_dir = PathBuf::from("schemas");
+
+    py.allow_threads(|| {
+        with_thread_pool(max_workers, || {
+            let dataset = core::DataSet::from_directories(&data_dir, &stores_dir, &schemas_dir);
+            log_step("Validating logos", Some(dataset.logo_entries.len()));
+
+            use rayon::prelude::*;
+            let results: Vec<core::ValidationResult> = dataset.logo_entries
+                .par_iter()
+                .map(|(path, filename, bytes, logo_name)| {
+                    if bytes.is_empty() {
+                        let mut r = core::ValidationResult::default();
+                        r.add(core::ValidationError::error(
+                            "Logo",
+                            "Logo file not found",
+                            Some(path.clone()),
+                        ));
+                        r
+                    } else {
+                        core::validators::validate_logo(bytes, filename, logo_name.as_deref(), Some(path))
+                    }
+                })
+                .collect();
+
+            let mut result = core::ValidationResult::default();
+            for r in results {
+                result.merge_from(&r);
+            }
+            result.into()
+        })
+    })
+}
+
+#[pyfunction]
+#[pyo3(signature = (data_dir, stores_dir, max_workers=None))]
+pub fn validate_folder_names(
+    py: Python<'_>,
+    data_dir: &str,
+    stores_dir: &str,
+    max_workers: Option<usize>,
+) -> ValidationResult {
+    let data_dir = PathBuf::from(data_dir);
+    let stores_dir = PathBuf::from(stores_dir);
+    let schemas_dir = PathBuf::from("schemas");
+
+    py.allow_threads(|| {
+        with_thread_pool(max_workers, || {
+            let dataset = core::DataSet::from_directories(&data_dir, &stores_dir, &schemas_dir);
+            log_step("Validating folder names", Some(dataset.folder_entries.len()));
+
+            use rayon::prelude::*;
+            let results: Vec<core::ValidationResult> = dataset.folder_entries
+                .par_iter()
+                .map(|(path, folder_name, json_data, json_key)| {
+                    core::validators::validate_folder_name(folder_name, json_data, json_key, Some(path))
+                })
+                .collect();
+
+            let mut result = core::ValidationResult::default();
+            for r in results {
+                result.merge_from(&r);
+            }
+            result.into()
+        })
+    })
+}

{ofd_validator-0.4.0 → ofd_validator-0.5.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "ofd-validator"
-version = "0.4.0"
+version = "0.5.0"
 description = "High-performance validation library for the Open Filament Database"
 readme = "README.md"
 requires-python = ">=3.10"

ofd_validator-0.4.0/crates/ofd-validator-python/src/orchestrator.rs

@@ -1,139 +0,0 @@
-use std::path::PathBuf;
-
-use pyo3::prelude::*;
-
-use ofd_validator_core as core;
-
-use crate::types::ValidationResult;
-use crate::util::log_step;
-
-#[pyfunction]
-#[pyo3(signature = (data_dir, stores_dir, schemas_dir=None))]
-pub fn validate_all(
-    py: Python<'_>,
-    data_dir: &str,
-    stores_dir: &str,
-    schemas_dir: Option<&str>,
-) -> ValidationResult {
-    let data_dir = PathBuf::from(data_dir);
-    let stores_dir = PathBuf::from(stores_dir);
-    let schemas_dir = PathBuf::from(schemas_dir.unwrap_or("schemas"));
-
-    py.allow_threads(|| {
-        log_step("Loading dataset", None);
-        let dataset = core::DataSet::from_directories(&data_dir, &stores_dir, &schemas_dir);
-
-        log_step("Checking required files", None);
-        log_step("Validating JSON schemas", Some(dataset.json_entries.len()));
-        log_step("Validating logos", Some(dataset.logo_entries.len()));
-        log_step("Validating folder names", Some(dataset.folder_entries.len()));
-        log_step("Validating store IDs", None);
-        log_step("Validating GTIN/EAN codes", None);
-
-        core::validate_dataset(&dataset).into()
-    })
-}
-
-#[pyfunction]
-#[pyo3(signature = (data_dir, stores_dir, schemas_dir=None))]
-pub fn validate_json_files(
-    py: Python<'_>,
-    data_dir: &str,
-    stores_dir: &str,
-    schemas_dir: Option<&str>,
-) -> ValidationResult {
-    let data_dir = PathBuf::from(data_dir);
-    let stores_dir = PathBuf::from(stores_dir);
-    let schemas_dir = PathBuf::from(schemas_dir.unwrap_or("schemas"));
-
-    py.allow_threads(|| {
-        let dataset = core::DataSet::from_directories(&data_dir, &stores_dir, &schemas_dir);
-        log_step("Validating JSON schemas", Some(dataset.json_entries.len()));
-
-        use rayon::prelude::*;
-        let results: Vec<core::ValidationResult> = dataset.json_entries
-            .par_iter()
-            .map(|(path, schema_name, data)| {
-                core::validators::validate_json(data, schema_name, &dataset.schema_cache, Some(path))
-            })
-            .collect();
-
-        let mut result = core::ValidationResult::default();
-        for r in results {
-            result.merge_from(&r);
-        }
-        result.into()
-    })
-}
-
-#[pyfunction]
-#[pyo3(signature = (data_dir, stores_dir))]
-pub fn validate_logo_files(
-    py: Python<'_>,
-    data_dir: &str,
-    stores_dir: &str,
-) -> ValidationResult {
-    let data_dir = PathBuf::from(data_dir);
-    let stores_dir = PathBuf::from(stores_dir);
-    let schemas_dir = PathBuf::from("schemas");
-
-    py.allow_threads(|| {
-        let dataset = core::DataSet::from_directories(&data_dir, &stores_dir, &schemas_dir);
-        log_step("Validating logos", Some(dataset.logo_entries.len()));
-
-        use rayon::prelude::*;
-        let results: Vec<core::ValidationResult> = dataset.logo_entries
-            .par_iter()
-            .map(|(path, filename, bytes, logo_name)| {
-                if bytes.is_empty() {
-                    let mut r = core::ValidationResult::default();
-                    r.add(core::ValidationError::error(
-                        "Logo",
-                        "Logo file not found",
-                        Some(path.clone()),
-                    ));
-                    r
-                } else {
-                    core::validators::validate_logo(bytes, filename, logo_name.as_deref(), Some(path))
-                }
-            })
-            .collect();
-
-        let mut result = core::ValidationResult::default();
-        for r in results {
-            result.merge_from(&r);
-        }
-        result.into()
-    })
-}
-
-#[pyfunction]
-#[pyo3(signature = (data_dir, stores_dir))]
-pub fn validate_folder_names(
-    py: Python<'_>,
-    data_dir: &str,
-    stores_dir: &str,
-) -> ValidationResult {
-    let data_dir = PathBuf::from(data_dir);
-    let stores_dir = PathBuf::from(stores_dir);
-    let schemas_dir = PathBuf::from("schemas");
-
-    py.allow_threads(|| {
-        let dataset = core::DataSet::from_directories(&data_dir, &stores_dir, &schemas_dir);
-        log_step("Validating folder names", Some(dataset.folder_entries.len()));
-
-        use rayon::prelude::*;
-        let results: Vec<core::ValidationResult> = dataset.folder_entries
-            .par_iter()
-            .map(|(path, folder_name, json_data, json_key)| {
-                core::validators::validate_folder_name(folder_name, json_data, json_key, Some(path))
-            })
-            .collect();
-
-        let mut result = core::ValidationResult::default();
-        for r in results {
-            result.merge_from(&r);
-        }
-        result.into()
-    })
-}