Sigma transitions (#223)

* Add SigmaMatcher

* First version working

* Clean

* Test sigma matcher

* Use SymbolTable in Fst's Display

* Save work

* Save work

* Save work

* Save work

* FFI sigma

* Fmt python

* Implement missing CDrop

* Fix clippy

* Clippy

Author: Garvys

rustfst-ffi/src/algorithms/compose.rs

@@ -2,11 +2,13 @@ use anyhow::{anyhow, Result};
 
 use super::EnumConversionError;
 use crate::fst::CFst;
-use crate::{get, wrap, RUSTFST_FFI_RESULT};
+use crate::{get, wrap, CLabel, RUSTFST_FFI_RESULT};
 
 use ffi_convert::*;
+use rustfst::algorithms::compose::matchers::MatcherRewriteMode;
 use rustfst::algorithms::compose::{
-    compose, compose_with_config, ComposeConfig, ComposeFilterEnum,
+    compose, compose_with_config, ComposeConfig, ComposeFilterEnum, MatcherConfig,
+    SigmaMatcherConfig,
 };
 use rustfst::fst_impls::VectorFst;
 use rustfst::semirings::TropicalWeight;
@@ -50,21 +52,149 @@ impl CReprOf<ComposeFilterEnum> for CComposeFilterEnum {
     }
 }
 
+#[derive(RawPointerConverter, Debug, Clone)]
+pub struct CMatcherRewriteMode(pub(crate) usize);
+
+impl AsRust<MatcherRewriteMode> for CMatcherRewriteMode {
+    fn as_rust(&self) -> Result<MatcherRewriteMode, AsRustError> {
+        match self.0 {
+            0 => Ok(MatcherRewriteMode::MatcherRewriteAuto),
+            1 => Ok(MatcherRewriteMode::MatcherRewriteAlways),
+            2 => Ok(MatcherRewriteMode::MatcherRewriteNever),
+            _ => Err(AsRustError::Other(Box::new(EnumConversionError {}))),
+        }
+    }
+}
+
+impl CDrop for CMatcherRewriteMode {
+    fn do_drop(&mut self) -> Result<(), CDropError> {
+        Ok(())
+    }
+}
+
+impl CReprOf<MatcherRewriteMode> for CMatcherRewriteMode {
+    fn c_repr_of(value: MatcherRewriteMode) -> Result<CMatcherRewriteMode, CReprOfError> {
+        let variant = match value {
+            MatcherRewriteMode::MatcherRewriteAuto => 0,
+            MatcherRewriteMode::MatcherRewriteAlways => 1,
+            MatcherRewriteMode::MatcherRewriteNever => 2,
+        };
+        Ok(CMatcherRewriteMode(variant))
+    }
+}
+
+#[derive(AsRust, CReprOf, CDrop, RawPointerConverter, Debug, Clone)]
+#[target_type(SigmaMatcherConfig)]
+pub struct CSigmaMatcherConfig {
+    pub sigma_label: CLabel,
+    pub rewrite_mode: CMatcherRewriteMode,
+}
+
+#[derive(RawPointerConverter, Debug, Clone, Default)]
+pub struct CMatcherConfig {
+    pub sigma_matcher_config: Option<CSigmaMatcherConfig>,
+}
+
+impl AsRust<MatcherConfig> for CMatcherConfig {
+    fn as_rust(&self) -> Result<MatcherConfig, AsRustError> {
+        if let Some(v) = &self.sigma_matcher_config {
+            Ok(MatcherConfig {
+                sigma_matcher_config: Some(v.as_rust()?),
+            })
+        } else {
+            Ok(MatcherConfig {
+                sigma_matcher_config: None,
+            })
+        }
+    }
+}
+
+impl CDrop for CMatcherConfig {
+    fn do_drop(&mut self) -> Result<(), CDropError> {
+        self.sigma_matcher_config
+            .as_mut()
+            .map(|v| v.do_drop())
+            .transpose()?;
+        Ok(())
+    }
+}
+
+impl CReprOf<MatcherConfig> for CMatcherConfig {
+    fn c_repr_of(input: MatcherConfig) -> Result<Self, CReprOfError> {
+        if let Some(v) = input.sigma_matcher_config {
+            Ok(Self {
+                sigma_matcher_config: Some(CReprOf::c_repr_of(v)?),
+            })
+        } else {
+            Ok(Self {
+                sigma_matcher_config: None,
+            })
+        }
+    }
+}
+
 #[derive(AsRust, CReprOf, CDrop, RawPointerConverter, Debug)]
 #[target_type(ComposeConfig)]
 pub struct CComposeConfig {
     pub compose_filter: CComposeFilterEnum,
     pub connect: bool,
+    pub matcher1_config: CMatcherConfig,
+    pub matcher2_config: CMatcherConfig,
+}
+
+#[no_mangle]
+pub extern "C" fn fst_matcher_config_new(
+    sigma_label: libc::size_t,
+    rewrite_mode: libc::size_t,
+    config: *mut *const CMatcherConfig,
+) -> RUSTFST_FFI_RESULT {
+    wrap(|| {
+        let matcher_config = CMatcherConfig {
+            sigma_matcher_config: Some(CSigmaMatcherConfig {
+                sigma_label: sigma_label as CLabel,
+                rewrite_mode: CMatcherRewriteMode(rewrite_mode as usize),
+            }),
+        };
+
+        unsafe { *config = matcher_config.into_raw_pointer() };
+        Ok(())
+    })
 }
 
 #[no_mangle]
 pub extern "C" fn fst_compose_config_new(
     compose_filter: libc::size_t,
     connect: bool,
+    matcher1_config: *const CMatcherConfig,
+    matcher2_config: *const CMatcherConfig,
     config: *mut *const CComposeConfig,
 ) -> RUSTFST_FFI_RESULT {
     wrap(|| {
+        let matcher1_config = if matcher1_config.is_null() {
+            CMatcherConfig::default()
+        } else {
+            unsafe {
+                <CMatcherConfig as ffi_convert::RawBorrow<CMatcherConfig>>::raw_borrow(
+                    matcher1_config,
+                )?
+            }
+            .clone()
+        };
+
+        let matcher2_config = if matcher2_config.is_null() {
+            CMatcherConfig::default()
+        } else {
+            unsafe {
+                <CMatcherConfig as ffi_convert::RawBorrow<CMatcherConfig>>::raw_borrow(
+                    matcher2_config,
+                )?
+            }
+            .clone()
+        };
+
         let compose_config = CComposeConfig {
+            matcher1_config,
+            matcher2_config,
             compose_filter: CComposeFilterEnum(compose_filter as usize),
             connect,
         };

rustfst-python/rustfst/algorithms/compose.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
 import ctypes
+from typing import Optional
+
 from rustfst.ffi_utils import (
     lib,
     check_ffi_error,
@@ -11,6 +13,25 @@
 from enum import Enum
 
 
+class MatcherRewriteMode(Enum):
+    AUTO = 0
+    ALWAYS = 1
+    NEVER = 2
+
+
+class MatcherConfig:
+    def __init__(self, sigma_label: int, rewrite_mode: MatcherRewriteMode):
+        config = ctypes.pointer(ctypes.c_void_p())
+        ret_code = lib.fst_matcher_config_new(
+            ctypes.c_size_t(sigma_label),
+            ctypes.c_size_t(rewrite_mode.value),
+            ctypes.byref(config),
+        )
+        err_msg = "Error creating MatcherConfig"
+        check_ffi_error(ret_code, err_msg)
+        self.ptr = config
+
+
 class ComposeFilter(Enum):
     AUTOFILTER = 0
     NULLFILTER = 1
@@ -22,21 +43,33 @@ class ComposeFilter(Enum):
 
 
 class ComposeConfig:
-    def __init__(self, compose_filter=None, connect: bool = None):
-        if compose_filter and connect is None:
-            self.ptr = compose_filter
-        elif compose_filter and connect:
-            config = ctypes.pointer(ctypes.c_void_p())
-            ret_code = lib.fst_compose_config_new(
-                ctypes.c_size_t(compose_filter.value),
-                ctypes.c_bool(connect),
-                ctypes.byref(config),
-            )
-            err_msg = "Error creating ComposeConfig"
-            check_ffi_error(ret_code, err_msg)
-            self.ptr = config
-        else:
-            raise ValueError("Could not create ComposeConfig")
+    def __init__(
+        self,
+        compose_filter: ComposeFilter = ComposeFilter.AUTOFILTER,
+        connect: bool = True,
+        matcher1_config: Optional[MatcherConfig] = None,
+        matcher2_config: Optional[MatcherConfig] = None,
+    ):
+        config = ctypes.pointer(ctypes.c_void_p())
+
+        m1_ptr = None
+        if matcher1_config is not None:
+            m1_ptr = matcher1_config.ptr
+        m2_ptr = None
+
+        if matcher2_config is not None:
+            m2_ptr = matcher2_config.ptr
+
+        ret_code = lib.fst_compose_config_new(
+            ctypes.c_size_t(compose_filter.value),
+            ctypes.c_bool(connect),
+            m1_ptr,
+            m2_ptr,
+            ctypes.byref(config),
+        )
+        err_msg = "Error creating ComposeConfig"
+        check_ffi_error(ret_code, err_msg)
+        self.ptr = config
 
 
 def compose(fst: VectorFst, other_fst: VectorFst) -> VectorFst:

rustfst-python/tests/algorithms/test_compose.py

@@ -1,5 +1,13 @@
 from rustfst import VectorFst, Tr
-from rustfst.algorithms.compose import ComposeFilter, ComposeConfig
+from rustfst.algorithms.compose import (
+    ComposeFilter,
+    ComposeConfig,
+    MatcherConfig,
+    MatcherRewriteMode,
+    compose_with_config,
+)
+from rustfst.symbol_table import SymbolTable
+from rustfst.algorithms import acceptor
 
 
 def test_compose_fst():
@@ -144,3 +152,26 @@ def test_compose_config():
 
     fst3 = fst1.compose(fst2, compose_config)
     assert fst3 == expected_fst
+
+
+def test_sigma_compose():
+    symt = SymbolTable.from_symbols(
+        ["<eps>", "play", "david", "queen", "please", "<sigma>"]
+    )
+
+    query_fst = acceptor("play queen please", symt)
+    sigma_fst = acceptor("play <sigma> please", symt)
+
+    matcher_config_right = MatcherConfig(
+        sigma_label=symt.find("<sigma>"), rewrite_mode=MatcherRewriteMode.AUTO
+    )
+
+    compose_config = ComposeConfig(
+        compose_filter=ComposeFilter.SEQUENCEFILTER,
+        connect=True,
+        matcher2_config=matcher_config_right,
+    )
+
+    res = compose_with_config(query_fst, sigma_fst, compose_config)
+
+    assert res == query_fst