toml-rs 0.0.11__tar.gz → 0.0.12__tar.gz

{toml_rs-0.0.11 → toml_rs-0.0.12}/Cargo.lock

@@ -290,14 +290,13 @@ dependencies = [
 
 [[package]]
 name = "toml-rs"
-version = "0.0.11"
+version = "0.0.12"
 dependencies = [
  "memchr",
  "mimalloc",
  "pyo3",
  "ryu",
  "toml",
- "toml_datetime",
 ]
 
 [[package]]

{toml_rs-0.0.11 → toml_rs-0.0.12}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "toml-rs"
-version = "0.0.11"
+version = "0.0.12"
 edition = "2024"
 license = "Unlicense"
 repository = "https://github.com/lava-sh/toml-rs"
@@ -19,7 +19,6 @@ toml = { version = "0.9.8", features = [
     "preserve_order", # save order
 ] }
 ryu = "1.0.20"
-toml_datetime = "0.7"
 memchr = { version = "2", default-features = false }
 mimalloc = { version = "*", features = ["v3"], optional = true }
 

{toml_rs-0.0.11 → toml_rs-0.0.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: toml-rs
-Version: 0.0.11
+Version: 0.0.12
 Classifier: Typing :: Typed
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python

{toml_rs-0.0.11 → toml_rs-0.0.12}/src/conversion.rs

@@ -5,13 +5,9 @@ use pyo3::{
     exceptions::{PyRecursionError, PyValueError},
     intern,
     prelude::*,
-    types::{
-        PyBool, PyDate, PyDateAccess, PyDateTime, PyDelta, PyDeltaAccess, PyDict, PyFloat, PyInt,
-        PyList, PyString, PyTime, PyTimeAccess, PyTzInfo, PyTzInfoAccess,
-    },
+    types::{self as t, PyDateAccess, PyDeltaAccess, PyTimeAccess, PyTzInfoAccess},
 };
-use toml::Value;
-use toml_datetime::Offset;
+use toml::{Value, value::Offset};
 
 const MAX_RECURSION_DEPTH: usize = 999;
 
@@ -38,10 +34,6 @@ impl RecursionGuard {
     }
 }
 
-pub(crate) fn python_to_toml<'py>(py: Python<'py>, obj: &Bound<'py, PyAny>) -> PyResult<Value> {
-    _python_to_toml(py, obj, &mut RecursionGuard::default())
-}
-
 pub(crate) fn toml_to_python<'py>(
     py: Python<'py>,
     value: Value,
@@ -65,7 +57,7 @@ fn _toml_to_python<'py>(
             if let Some(f) = parse_float {
                 let mut buf = ryu::Buffer::new();
                 let py_call = f.call1((buf.format(float),))?;
-                if py_call.cast::<PyDict>().is_ok() || py_call.cast::<PyList>().is_ok() {
+                if py_call.cast::<t::PyDict>().is_ok() || py_call.cast::<t::PyList>().is_ok() {
                     return Err(PyValueError::new_err(
                         "parse_float must not return dicts or lists",
                     ));
@@ -77,14 +69,14 @@ fn _toml_to_python<'py>(
         }
         Value::Boolean(bool) => bool.into_bound_py_any(py),
         Value::Array(array) => {
-            let py_list = PyList::empty(py);
+            let py_list = t::PyList::empty(py);
             for item in array {
                 py_list.append(_toml_to_python(py, item, parse_float, recursion)?)?;
             }
             Ok(py_list.into_any())
         }
         Value::Table(table) => {
-            let py_dict = PyDict::new(py);
+            let py_dict = t::PyDict::new(py);
             for (k, v) in table {
                 let value = _toml_to_python(py, v, parse_float, recursion)?;
                 py_dict.set_item(k, value)?;
@@ -100,11 +92,11 @@ fn _toml_to_python<'py>(
                 Ok(crate::create_py_datetime!(py, date, time, None)?.into_any())
             }
             (Some(date), None, None) => {
-                let py_date = PyDate::new(py, date.year as i32, date.month, date.day)?;
+                let py_date = t::PyDate::new(py, date.year as i32, date.month, date.day)?;
                 Ok(py_date.into_any())
             }
             (None, Some(time), None) => {
-                let py_time = PyTime::new(
+                let py_time = t::PyTime::new(
                     py,
                     time.hour,
                     time.minute,
@@ -124,9 +116,9 @@ fn _toml_to_python<'py>(
 fn create_timezone_from_offset<'py>(
     py: Python<'py>,
     offset: &Offset,
-) -> PyResult<Bound<'py, PyTzInfo>> {
+) -> PyResult<Bound<'py, t::PyTzInfo>> {
     match offset {
-        Offset::Z => PyTzInfo::utc(py).map(|utc| utc.to_owned()),
+        Offset::Z => t::PyTzInfo::utc(py).map(|utc| utc.to_owned()),
         Offset::Custom { minutes } => {
             let seconds = *minutes as i32 * 60;
             let (days, seconds) = if seconds < 0 {
@@ -136,8 +128,8 @@ fn create_timezone_from_offset<'py>(
             } else {
                 (0, seconds)
             };
-            let py_delta = PyDelta::new(py, days, seconds, 0, false)?;
-            PyTzInfo::fixed_offset(py, py_delta)
+            let py_delta = t::PyDelta::new(py, days, seconds, 0, false)?;
+            t::PyTzInfo::fixed_offset(py, py_delta)
         }
     }
 }
@@ -176,6 +168,10 @@ pub(crate) fn normalize_line_ending(s: &'_ str) -> Cow<'_, str> {
     }
 }
 
+pub(crate) fn python_to_toml<'py>(py: Python<'py>, obj: &Bound<'py, PyAny>) -> PyResult<Value> {
+    _python_to_toml(py, obj, &mut RecursionGuard::default())
+}
+
 #[inline]
 fn _python_to_toml<'py>(
     py: Python<'py>,
@@ -184,46 +180,43 @@ fn _python_to_toml<'py>(
 ) -> PyResult<Value> {
     recursion.enter()?;
 
-    let value = if let Ok(str) = obj.cast::<PyString>() {
+    let toml = if let Ok(str) = obj.cast::<t::PyString>() {
         Value::String(str.to_string())
-    } else if let Ok(bool) = obj.cast::<PyBool>() {
+    } else if let Ok(bool) = obj.cast::<t::PyBool>() {
         Value::Boolean(bool.is_true())
-    } else if let Ok(int) = obj.cast::<PyInt>() {
+    } else if let Ok(int) = obj.cast::<t::PyInt>() {
         Value::Integer(int.extract()?)
-    } else if let Ok(float) = obj.cast::<PyFloat>() {
+    } else if let Ok(float) = obj.cast::<t::PyFloat>() {
         Value::Float(float.value())
-    } else if let Ok(dict) = obj.cast::<PyDict>() {
+    } else if let Ok(dict) = obj.cast::<t::PyDict>() {
         let mut table = toml::map::Map::with_capacity(dict.len());
         for (k, v) in dict.iter() {
             let key = k
-                .cast::<PyString>()
+                .cast::<t::PyString>()
                 .map_err(|_| {
-                    crate::TOMLEncodeError::new_err((
-                        format!(
-                            "TOML table keys must be strings, got {}",
-                            crate::get_repr!(k)
-                        ),
-                        Some(k.clone().unbind()),
+                    crate::TOMLEncodeError::new_err(format!(
+                        "TOML table keys must be strings, got {}",
+                        crate::get_type!(k)
                     ))
                 })?
                 .to_string();
             table.insert(key, _python_to_toml(py, &v, recursion)?);
         }
         Value::Table(table)
-    } else if let Ok(list) = obj.cast::<PyList>() {
+    } else if let Ok(list) = obj.cast::<t::PyList>() {
         let mut vec = Vec::with_capacity(list.len());
         for item in list.iter() {
             vec.push(_python_to_toml(py, &item, recursion)?);
         }
         Value::Array(vec)
-    } else if let Ok(dt) = obj.cast::<PyDateTime>() {
-        Value::Datetime(toml_datetime::Datetime {
-            date: Some(toml_datetime::Date {
+    } else if let Ok(dt) = obj.cast::<t::PyDateTime>() {
+        Value::Datetime(toml::value::Datetime {
+            date: Some(toml::value::Date {
                 year: dt.get_year() as u16,
                 month: dt.get_month(),
                 day: dt.get_day(),
             }),
-            time: Some(toml_datetime::Time {
+            time: Some(toml::value::Time {
                 hour: dt.get_hour(),
                 minute: dt.get_minute(),
                 second: dt.get_second(),
@@ -234,7 +227,7 @@ fn _python_to_toml<'py>(
                 if utc_offset.is_none() {
                     None
                 } else {
-                    let delta = utc_offset.cast::<PyDelta>()?;
+                    let delta = utc_offset.cast::<t::PyDelta>()?;
                     let total_seconds = delta.get_days() * 86400 + delta.get_seconds();
                     Some(Offset::Custom {
                         minutes: (total_seconds / 60) as i16,
@@ -244,9 +237,9 @@ fn _python_to_toml<'py>(
                 None
             },
         })
-    } else if let Ok(date) = obj.cast::<PyDate>() {
-        Value::Datetime(toml_datetime::Datetime {
-            date: Some(toml_datetime::Date {
+    } else if let Ok(date) = obj.cast::<t::PyDate>() {
+        Value::Datetime(toml::value::Datetime {
+            date: Some(toml::value::Date {
                 year: date.get_year() as u16,
                 month: date.get_month(),
                 day: date.get_day(),
@@ -254,10 +247,10 @@ fn _python_to_toml<'py>(
             time: None,
             offset: None,
         })
-    } else if let Ok(time) = obj.cast::<PyTime>() {
-        Value::Datetime(toml_datetime::Datetime {
+    } else if let Ok(time) = obj.cast::<t::PyTime>() {
+        Value::Datetime(toml::value::Datetime {
             date: None,
-            time: Some(toml_datetime::Time {
+            time: Some(toml::value::Time {
                 hour: time.get_hour(),
                 minute: time.get_minute(),
                 second: time.get_second(),
@@ -266,11 +259,11 @@ fn _python_to_toml<'py>(
             offset: None,
         })
     } else {
-        return Err(crate::TOMLEncodeError::new_err((
-            format!("Cannot serialize {} to TOML", crate::get_repr!(obj)),
-            Some(obj.clone().unbind()),
+        return Err(crate::TOMLEncodeError::new_err(format!(
+            "Cannot serialize {} to TOML",
+            crate::get_type!(obj)
         )));
     };
     recursion.exit();
-    Ok(value)
+    Ok(toml)
 }

{toml_rs-0.0.11 → toml_rs-0.0.12}/src/macros.rs

@@ -1,7 +1,7 @@
 #[macro_export]
 macro_rules! create_py_datetime {
     ($py:expr, $date:expr, $time:expr, $tzinfo:expr) => {
-        PyDateTime::new(
+        t::PyDateTime::new(
             $py,
             $date.year as i32,
             $date.month,
@@ -16,10 +16,17 @@ macro_rules! create_py_datetime {
 }
 
 #[macro_export]
-macro_rules! get_repr {
+macro_rules! get_type {
     ($obj:expr) => {
-        $obj.repr()
-            .map(|s| s.to_string())
-            .unwrap_or_else(|_| "<unknown>".to_string())
+        format!(
+            "{} ({})",
+            $obj.repr()
+                .map(|s| s.to_string())
+                .unwrap_or_else(|_| String::from("<unknown>")),
+            $obj.get_type()
+                .repr()
+                .map(|s| s.to_string())
+                .unwrap_or_else(|_| String::from("<unknown>"))
+        )
     };
 }

{toml_rs-0.0.11 → toml_rs-0.0.12}/tests/test_dumps.py

@@ -1,5 +1,5 @@
-import re
 from datetime import datetime, timedelta, timezone
+from re import escape as e
 
 import pytest
 import toml_rs
@@ -11,29 +11,29 @@ import toml_rs
         (
             pytest.param(
                 type("_Class", (), {}),
-                r"Cannot serialize <class '.*_Class'",
+                r"Cannot serialize <class '.*_Class'> \(<class 'type'>\)",
                 id="class",
             )
         ),
         (
             {"x": lambda x: x},
-            r"Cannot serialize <function .*<lambda>",
+            r"Cannot serialize <function <lambda> at 0x.*> \(<class 'function'>\)",
         ),
         (
             {"x": 1 + 2j},
-            re.escape("Cannot serialize (1+2j)"),
+            e("Cannot serialize (1+2j) (<class 'complex'>)"),
         ),
         (
             {"set": {1, 2, 3}},
-            r"Cannot serialize {1, 2, 3}",
+            r"Cannot serialize {1, 2, 3} \(<class 'set'>\)",
         ),
         (
             {"valid": {"invalid": object()}},
-            r"Cannot serialize <object object at",
+            r"Cannot serialize <object object at 0x.*> \(<class 'object'>\)",
         ),
         (
             {42: "value"},
-            r"TOML table keys must be strings, got 42",
+            e("TOML table keys must be strings, got 42 (<class 'int'>)"),
         ),
     ],
 )