feat: added functionality for LCAbyg data

docs/code/python/usage.py

@@ -9,9 +9,9 @@
 print(json.dumps(epd_dict, indent=2))
 
 print("\nEPD as Pydantic model")
-epd_pydantic = epdx.convert_ilcd(ilcd_file.read_text(), as_type="pydantic")
+epd_pydantic = epdx.convert_ilcd(ilcd_file.read_text(), as_type=epdx.EPD)
 print(epd_pydantic)
 
 print("\nEPD as string")
-epd_str = epdx.convert_ilcd(ilcd_file.read_text(), as_type="str")
+epd_str = epdx.convert_ilcd(ilcd_file.read_text(), as_type=str)
 print(epd_str)

pyproject.toml

@@ -2,7 +2,7 @@
 name = "epdx"
 description = "EPDx is a library for parsing EPD files into a common exchange format."
 readme = "README.md"
-requires-python = ">=3.8"
+requires-python = ">=3.10"
 license = { file = "LICENSE" }
 authors = [
     { name = "Christian Kongsgaard", email = "christian@kongsgaard.eu" },

src/ilcd.rs

@@ -1,8 +1,7 @@
 #[allow(dead_code)]
-use serde::{Deserialize};
+use serde::Deserialize;
 use serde::Serialize;
 
-
 #[derive(Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct ILCD {
@@ -11,7 +10,7 @@ pub struct ILCD {
     pub exchanges: Exchanges,
     #[serde(alias = "LCIAResults")]
     pub lcia_results: LCIAResults,
-    pub version: String
+    pub version: String,
 }
 
 #[derive(Deserialize)]
@@ -20,7 +19,6 @@ pub struct Exchanges {
     pub exchange: Vec<Exchange>,
 }
 
-
 #[derive(Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct Exchange {
@@ -37,10 +35,9 @@ pub struct Exchange {
 
     #[serde(alias = "exchange direction")]
     pub exchange_direction: Option<String>,
-    pub other: Option<LCIAAnies>
+    pub other: Option<LCIAAnies>,
 }
 
-
 #[derive(Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct FlowProperty {
@@ -50,7 +47,7 @@ pub struct FlowProperty {
     pub reference_flow_property: Option<bool>,
     pub reference_unit: Option<String>,
     #[serde(alias = "unitGroupUUID")]
-    pub unit_group_uuid: Option<String>
+    pub unit_group_uuid: Option<String>,
 }
 
 #[derive(Deserialize, Serialize)]
@@ -67,7 +64,7 @@ pub struct MaterialProperty {
 pub struct ModellingAndValidation {
     #[serde(alias = "LCIMethodAndAllocation")]
     pub lci_method_and_allocation: LCIMethodAndAllocation,
-    pub compliance_declarations: ComplianceDeclarations
+    pub compliance_declarations: ComplianceDeclarations,
 }
 
 #[derive(Deserialize)]
@@ -88,10 +85,9 @@ pub struct ReferenceToDescription {
     pub short_description: Vec<ValueLang>,
     pub _type: String,
     // pub ref_object_id: Option<String>,
-    pub version: Option<String>
+    pub version: Option<String>,
 }
 
-
 #[derive(Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct LCIAResults {
@@ -104,23 +100,22 @@ pub struct LCIAResults {
 pub struct LCIAResult {
     #[serde(alias = "referenceToLCIAMethodDataSet")]
     pub reference_to_lcia_method_dataset: ReferenceToLCIAMethodDataSet,
-    pub other: LCIAAnies
+    pub other: LCIAAnies,
 }
 
 #[derive(Deserialize, Debug)]
 #[serde(rename_all = "camelCase")]
 pub struct LCIAAnies {
-    pub anies: Vec<ModuleAnie>
+    pub anies: Vec<ModuleAnie>,
 }
 
 #[derive(Deserialize, Debug)]
 #[serde(rename_all = "camelCase")]
 pub struct ModuleAnie {
     pub module: Option<String>,
-    pub value: Option<AnieValue>
+    pub value: Option<AnieValue>,
 }
 
-
 #[derive(Debug, Deserialize)]
 #[serde(untagged)]
 pub enum AnieValue {
@@ -135,7 +130,7 @@ impl From<&AnieValue> for f64 {
                 // Parse the string into a float
                 let float_value = s.parse::<f64>().unwrap();
                 float_value
-            },
+            }
             AnieValue::ValueObject(_) => {
                 panic!("Cannot convert AnieValue::ValueObject to f64");
             }
@@ -154,12 +149,12 @@ pub struct ValueObject {
 #[derive(Deserialize, Debug)]
 pub enum ModuleValue {
     Value(String),
-    Name(ModuleMap)
+    Name(ModuleMap),
 }
 
 #[derive(Deserialize, Debug)]
 pub struct ModuleMap {
-    name: String
+    name: String,
 }
 
 #[derive(Deserialize, Debug)]
@@ -177,34 +172,34 @@ pub struct LCIMethodAndAllocation {
 #[derive(Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct Anies {
-    pub anies: Vec<Anie>
+    pub anies: Vec<Anie>,
 }
 
 #[derive(Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct Anie {
     pub name: String,
-    pub value: String
+    pub value: String,
 }
 
 #[derive(Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct ProcessInformation {
     pub data_set_information: DataSetInformation,
     pub time: TimeData,
-    pub geography: Geography
+    pub geography: Geography,
 }
 
 #[derive(Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct Geography {
-    pub location_of_operation_supply_or_production: LocationOfOperationSupplyOrProduction
+    pub location_of_operation_supply_or_production: LocationOfOperationSupplyOrProduction,
 }
 
 #[derive(Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct LocationOfOperationSupplyOrProduction {
-    pub location: String
+    pub location: String,
 }
 
 #[derive(Deserialize)]
@@ -219,7 +214,7 @@ pub struct TimeData {
 pub struct DataSetInformation {
     #[serde(alias = "UUID")]
     pub uuid: String,
-    pub name: DataSetName
+    pub name: DataSetName,
 }
 
 #[derive(Deserialize)]
@@ -231,5 +226,5 @@ pub struct DataSetName {
 #[derive(Deserialize, Debug)]
 pub struct ValueLang {
     pub value: String,
-    pub lang: String
-}
+    pub lang: String,
+}

src/javascript.rs

@@ -1,7 +1,6 @@
-use wasm_bindgen::prelude::*;
 use crate::epd::EPD;
 use crate::parse;
-
+use wasm_bindgen::prelude::*;
 
 // When the `wee_alloc` feature is enabled, use `wee_alloc` as the global
 // allocator.
@@ -20,7 +19,6 @@ pub fn convertIlcd(json: String) -> Result<EPD, JsError> {
     let epd = parse::parse_ilcd(json);
     match epd {
         Ok(epd) => Ok(epd),
-        Err(error) => Err(JsError::new(error.to_string().as_str()))
+        Err(error) => Err(JsError::new(error.to_string().as_str())),
     }
 }
-

src/lcabyg.rs

@@ -1,19 +1,17 @@
 use serde::{Deserialize, Serialize};
 
-use crate::epd::{Conversion, EPD, ImpactCategory, Source, Standard, SubType, Unit};
+use crate::epd::{Conversion, ImpactCategory, Source, Standard, SubType, Unit, EPD};
 use crate::utils::get_version;
 
-
 #[derive(Deserialize, Serialize)]
 pub enum Nodes {
     Node(Node),
 }
 
-
 #[derive(Serialize, Deserialize)]
 #[serde(rename_all = "PascalCase")]
 pub enum Node {
-    Stage(Stage)
+    Stage(Stage),
 }
 
 #[derive(Serialize, Deserialize, Clone)]
@@ -76,7 +74,11 @@ impl From<&Vec<Stage>> for EPD {
         let mut penr = ImpactCategory::new();
 
         for stage in stages {
-            let stage_name = if stage.stage == "A1to3" { "A1A3" } else { &stage.stage };
+            let stage_name = if stage.stage == "A1to3" {
+                "A1A3"
+            } else {
+                &stage.stage
+            };
 
             ep.add(stage_name, stage.indicators.ep);
             odp.add(stage_name, stage.indicators.odp);
@@ -134,13 +136,15 @@ impl From<&Vec<Stage>> for EPD {
             format_version: get_version(),
             reference_service_life: None,
             location: "".to_string(),
-            conversions: Some(vec![
-                Conversion { to: Unit::KG, value: node.mass_factor, meta_data: "".to_string() }
-            ]),
+            conversions: Some(vec![Conversion {
+                to: Unit::KG,
+                value: node.mass_factor,
+                meta_data: "".to_string(),
+            }]),
             perm: None,
             meta_data: None,
         };
 
         epd
     }
-}
+}

src/lib.rs

@@ -1,9 +1,9 @@
+pub mod epd;
 #[allow(dead_code)]
 pub mod ilcd;
-mod utils;
-pub mod parse;
-pub mod epd;
 pub mod lcabyg;
+pub mod parse;
+mod utils;
 
 #[cfg(feature = "jsbindings")]
 mod javascript;
@@ -16,6 +16,6 @@ pub fn convert_ilcd(json: String) -> String {
     let epd = parse::parse_ilcd(json);
     match epd {
         Ok(epd) => serde_json::to_string(&epd).unwrap(),
-        Err(_) => String::from("")
+        Err(_) => String::from(""),
     }
-}
+}

src/parse.rs

@@ -1,5 +1,5 @@
-use serde_json::Error;
 use crate::epd::EPD;
+use serde_json::Error;
 
 /// Parse a ILCD formatted EPD in an EPDx struct
 ///
@@ -12,6 +12,6 @@ pub fn parse_ilcd(json: String) -> Result<EPD, Error> {
     let epd = serde_json::from_str(&json);
     match epd {
         Ok(epd) => Ok(epd),
-        Err(err) => Err(err)
+        Err(err) => Err(err),
     }
 }

src/python.rs

@@ -1,14 +1,14 @@
-use pyo3::prelude::*;
-use pyo3::exceptions::PyTypeError;
 use crate::parse;
+use pyo3::exceptions::PyTypeError;
+use pyo3::prelude::*;
 
 #[cfg(feature = "pybindings")]
 #[pyfunction]
 pub fn _convert_ilcd(json: String) -> PyResult<String> {
     let epd = parse::parse_ilcd(json);
     match epd {
         Ok(epd) => Ok(serde_json::to_string(&epd).unwrap()),
-        Err(error) => Err(PyTypeError::new_err(error.to_string()))
+        Err(error) => Err(PyTypeError::new_err(error.to_string())),
     }
 }
 
@@ -21,4 +21,4 @@ fn epdx(_py: Python, m: &PyModule) -> PyResult<()> {
     m.add_function(wrap_pyfunction!(_convert_ilcd, m)?)?;
 
     Ok(())
-}
+}

src/schemars.rs

@@ -1,9 +1,9 @@
-use schemars::{schema_for};
+use schemars::schema_for;
 extern crate epdx;
 
 use epdx::epd;
 
 fn main() {
     let schema = schema_for!(epd::EPD);
     println!("{}", serde_json::to_string_pretty(&schema).unwrap());
-}
+}

src/utils.rs

@@ -11,7 +11,11 @@ pub fn set_panic_hook() {
     console_error_panic_hook::set_once();
 }
 
-
 pub fn get_version() -> String {
-    format!("{}.{}.{}", pkg_version_major!(), pkg_version_minor!(), pkg_version_patch!())
-}
+    format!(
+        "{}.{}.{}",
+        pkg_version_major!(),
+        pkg_version_minor!(),
+        pkg_version_patch!()
+    )
+}

tests/test_parse_ilcd.rs

@@ -1,9 +1,10 @@
 #[cfg(test)]
 mod tests {
-    use epdx::*;
     use std::fs;
     use std::path::Path;
-    use epdx::epd::{Standard, SubType};
+
+    use epdx::*;
+    use epdx::epd::Standard;
 
     macro_rules! parse_ilcd_tests {
     ($($name:ident: $value:expr)*) => {