[ffe] add pyo3 conversion methods

datadog-ffe/Cargo.toml

@@ -20,8 +20,9 @@ md5 = { version = "0.7.0", default-features = false }
 regex = "1.10.4"
 serde-bool = { version = "0.1.3", default-features = false }
 serde_with = { version = "3.11.0", default-features = false, features = ["base64", "hex", "macros"] }
-thiserror = "2.0.3"
-url = "2.5.0"
+thiserror = { version = "2.0.3", default-features = false }
+url = { version = "2.5.0", default-features = false, features = ["std"] }
+pyo3 = { version = "0.25", optional = true, default-features = false, features = ["macros"] }
 
 [dev-dependencies]
 env_logger = "0.10"
@@ -31,3 +32,6 @@ criterion = { version = "0.5", features = ["html_reports"] }
 name = "ffe-eval"
 harness = false
 path = "benches/eval.rs"
+
+[features]
+pyo3 = ["dep:pyo3"]

datadog-ffe/src/lib.rs

@@ -2,3 +2,6 @@
 // SPDX-License-Identifier: Apache-2.0
 
 pub mod rules_based;
+
+#[cfg(feature = "pyo3")]
+pub mod pyo3;

datadog-ffe/src/pyo3.rs

@@ -0,0 +1,14 @@
+// Copyright 2025-Present Datadog, Inc. https://www.datadoghq.com/
+// SPDX-License-Identifier: Apache-2.0
+
+use pyo3::prelude::*;
+
+use crate::rules_based::{Assignment, AssignmentReason};
+
+/// Initialize FFE Python classes under the given module.
+pub fn init(m: &Bound<PyModule>) -> PyResult<()> {
+    m.add_class::<AssignmentReason>()?;
+    m.add_class::<Assignment>()?;
+
+    Ok(())
+}

datadog-ffe/src/rules_based/attributes.rs

@@ -10,10 +10,10 @@ use crate::rules_based::Str;
 /// Attribute for evaluation context. See `From` implementations for initialization.
 #[derive(Debug, Clone, PartialEq, PartialOrd, derive_more::From, Serialize, Deserialize)]
 #[from(f64, bool, Str, String, &str, Arc<str>, Arc<String>, Cow<'_, str>)]
-pub struct Attribute(AttributeValueImpl);
+pub struct Attribute(AttributeImpl);
 #[derive(Debug, Clone, PartialEq, PartialOrd, Serialize, Deserialize, derive_more::From)]
 #[serde(untagged)]
-enum AttributeValueImpl {
+enum AttributeImpl {
     #[from]
     Number(f64),
     #[from(forward)]
@@ -26,7 +26,7 @@ enum AttributeValueImpl {
 
 impl Attribute {
     pub(crate) fn is_null(&self) -> bool {
-        self == &Attribute(AttributeValueImpl::Null)
+        self == &Attribute(AttributeImpl::Null)
     }
 
     /// Try coercing attribute to a number.
@@ -35,8 +35,8 @@ impl Attribute {
     /// number.
     pub(crate) fn coerce_to_number(&self) -> Option<f64> {
         match &self.0 {
-            AttributeValueImpl::Number(v) => Some(*v),
-            AttributeValueImpl::String(s) => s.parse().ok(),
+            AttributeImpl::Number(v) => Some(*v),
+            AttributeImpl::String(s) => s.parse().ok(),
             _ => None,
         }
     }
@@ -46,19 +46,61 @@ impl Attribute {
     /// String attributes are returned as is. Number and boolean attributes are converted to string.
     pub(crate) fn coerce_to_string(&self) -> Option<Cow<'_, str>> {
         match &self.0 {
-            AttributeValueImpl::String(s) => Some(Cow::Borrowed(s)),
-            AttributeValueImpl::Number(v) => Some(Cow::Owned(v.to_string())),
-            AttributeValueImpl::Boolean(v) => {
-                Some(Cow::Borrowed(if *v { "true" } else { "false" }))
-            }
-            AttributeValueImpl::Null => None,
+            AttributeImpl::String(s) => Some(Cow::Borrowed(s)),
+            AttributeImpl::Number(v) => Some(Cow::Owned(v.to_string())),
+            AttributeImpl::Boolean(v) => Some(Cow::Borrowed(if *v { "true" } else { "false" })),
+            AttributeImpl::Null => None,
         }
     }
 
     pub(crate) fn as_str(&self) -> Option<&Str> {
         match self {
-            Attribute(AttributeValueImpl::String(s)) => Some(s),
+            Attribute(AttributeImpl::String(s)) => Some(s),
             _ => None,
         }
     }
 }
+
+#[cfg(feature = "pyo3")]
+mod pyo3_impl {
+    use super::*;
+
+    use pyo3::{
+        exceptions::PyTypeError,
+        prelude::*,
+        types::{PyBool, PyFloat, PyInt, PyString},
+    };
+
+    /// Convert Python value to Attribute.
+    ///
+    /// The following types are currently supported:
+    /// - `str`
+    /// - `int`
+    /// - `float`
+    /// - `bool`
+    /// - `NoneType`
+    ///
+    /// Note that nesting is not currently supported and will throw an error.
+    impl<'py> FromPyObject<'py> for Attribute {
+        #[inline]
+        fn extract_bound(value: &Bound<'py, PyAny>) -> PyResult<Self> {
+            if let Ok(s) = value.downcast::<PyString>() {
+                return Ok(Attribute(AttributeImpl::String(s.to_cow()?.into())));
+            }
+            // In Python, Bool inherits from Int, so it must be checked first here.
+            if let Ok(s) = value.downcast::<PyBool>() {
+                return Ok(Attribute(AttributeImpl::Boolean(s.is_true())));
+            }
+            if let Ok(s) = value.downcast::<PyFloat>() {
+                return Ok(Attribute(AttributeImpl::Number(s.value())));
+            }
+            if let Ok(s) = value.downcast::<PyInt>() {
+                return Ok(Attribute(AttributeImpl::Number(s.extract::<f64>()?)));
+            }
+            if value.is_none() {
+                return Ok(Attribute(AttributeImpl::Null));
+            }
+            Err(PyTypeError::new_err("invalid type for attribute"))
+        }
+    }
+}

datadog-ffe/src/rules_based/eval/evaluation_context.rs

@@ -49,3 +49,60 @@ impl EvaluationContext {
         None
     }
 }
+
+#[cfg(feature = "pyo3")]
+mod pyo3_impl {
+    use super::*;
+
+    use pyo3::{intern, prelude::*, types::PyDict};
+
+    /// Accepts either a dict with `"targeting_key"` and `"attributes"` items, or any object with
+    /// `targeting_key` and `attributes` attributes.
+    ///
+    /// # Examples
+    ///
+    /// ```python
+    /// {"targeting_key": "user1", "attributes": {"attr1": 42}}
+    /// ```
+    ///
+    /// ```python
+    /// @dataclass
+    /// class EvaluationContext:
+    ///     targeting_key: Optional[str]
+    ///     attributes: dict[str, Any]
+    ///
+    /// EvaluationContext(targeting_key="user1", attributes={"attr1": 42})
+    /// ```
+    impl<'py> FromPyObject<'py> for EvaluationContext {
+        #[inline]
+        fn extract_bound(value: &Bound<'py, PyAny>) -> PyResult<Self> {
+            let py = value.py();
+
+            let (targeting_key, attributes) = if let Ok(dict) = value.downcast::<PyDict>() {
+                (
+                    dict.get_item(intern!(py, "targeting_key"))?,
+                    dict.get_item(intern!(py, "attributes"))?,
+                )
+            } else {
+                (
+                    value.getattr_opt(intern!(py, "targeting_key"))?,
+                    value.getattr_opt(intern!(py, "attributes"))?,
+                )
+            };
+
+            let context = EvaluationContext {
+                targeting_key: targeting_key
+                    .map(|it| it.extract())
+                    .transpose()?
+                    .unwrap_or_else(|| Str::from_static_str("").into()),
+                attributes: attributes
+                    .map(|it| it.extract())
+                    .transpose()?
+                    .map(Arc::new)
+                    .unwrap_or_default(),
+            };
+
+            Ok(context)
+        }
+    }
+}

datadog-ffe/src/rules_based/str.rs

@@ -111,3 +111,31 @@ impl log::kv::ToValue for Str {
         log::kv::Value::from_display(self)
     }
 }
+
+#[cfg(feature = "pyo3")]
+mod pyo3_impl {
+    use std::convert::Infallible;
+
+    use super::*;
+
+    use pyo3::{prelude::*, types::PyString};
+
+    impl<'py> FromPyObject<'py> for Str {
+        #[inline]
+        fn extract_bound(value: &Bound<'py, PyAny>) -> PyResult<Self> {
+            let s = value.downcast::<PyString>()?;
+            Ok(Str::from(s.to_cow()?))
+        }
+    }
+
+    impl<'py> IntoPyObject<'py> for &Str {
+        type Target = PyString;
+        type Output = Bound<'py, PyString>;
+        type Error = Infallible;
+
+        #[inline]
+        fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+            Ok(PyString::new(py, self.as_str()))
+        }
+    }
+}