feat: update general-sam to 0.5.2

Author: ChieloNewctle

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "general-sam-py"
-version = "0.4.2"
+version = "0.5.2-dev"
 edition = "2021"
 license = "MIT OR Apache-2.0"
 description = "Python bindings for general-sam and some utilities"
@@ -14,7 +14,7 @@ name = "general_sam"
 crate-type = ["cdylib"]
 
 [dependencies]
-general-sam = { version = "0.4.2", features = ["all"] }
+general-sam = { version = "0.5.2", features = ["all"] }
 pyo3 = { version = "0.20.0", features = [
   "extension-module",
   "abi3-py38",

README.md

@@ -45,7 +45,7 @@ pip install general-sam
 from general_sam import GeneralSAM
 
 
-sam = GeneralSAM.construct_from_bytes(b'abcbc')
+sam = GeneralSAM.from_bytes(b'abcbc')
 
 # "cbc" is a suffix of "abcbc"
 state = sam.get_root_state()
@@ -62,7 +62,7 @@ assert not state.is_accepting()
 from general_sam import GeneralSAM
 
 
-sam = GeneralSAM.construct_from_chars('abcbc')
+sam = GeneralSAM.from_chars('abcbc')
 state = sam.get_root_state()
 
 # "b" is not a suffix but at least a substring of "abcbc"
@@ -83,11 +83,11 @@ assert not state.is_accepting() and state.is_nil()
 ```
 
 ```python
-from general_sam import GeneralSAM, GeneralSAMState, construct_trie_from_chars
+from general_sam import GeneralSAM, GeneralSAMState, build_trie_from_chars
 
 
-trie, _ = construct_trie_from_chars(['hello', 'Chielo'])
-sam = GeneralSAM.construct_from_trie(trie)
+trie, _ = build_trie_from_chars(['hello', 'Chielo'])
+sam = GeneralSAM.from_trie(trie)
 
 def fetch_state(s: str) -> GeneralSAMState:
     state = sam.get_root_state()

general_sam/__init__.py

@@ -7,8 +7,8 @@
 from .trie_utils import (
     CountInfo,
     SortResult,
-    construct_trie_from_bytes,
-    construct_trie_from_chars,
+    build_trie_from_bytes,
+    build_trie_from_chars,
     sort_bytes,
     sort_chars,
     sort_seq_via_trie,
@@ -25,8 +25,8 @@
     'TrieNode',
     'CountInfo',
     'SortResult',
-    'construct_trie_from_chars',
-    'construct_trie_from_bytes',
+    'build_trie_from_chars',
+    'build_trie_from_bytes',
     'sort_chars',
     'sort_bytes',
     'sort_seq_via_trie',

general_sam/general_sam.pyi

@@ -72,11 +72,11 @@ class GeneralSAMState:
 
 class GeneralSAM:
     @staticmethod
-    def construct_from_chars(s: str) -> 'GeneralSAM': ...
+    def from_chars(s: str) -> 'GeneralSAM': ...
     @staticmethod
-    def construct_from_bytes(s: bytes) -> 'GeneralSAM': ...
+    def from_bytes(s: bytes) -> 'GeneralSAM': ...
     @staticmethod
-    def construct_from_trie(trie: Trie) -> 'GeneralSAM': ...
+    def from_trie(trie: Trie) -> 'GeneralSAM': ...
     def is_in_str(self) -> bool: ...
     def is_in_bytes(self) -> bool: ...
     def num_of_nodes(self) -> int: ...

general_sam/trie_utils.py

@@ -4,15 +4,15 @@
 from .general_sam import Trie
 
 
-def construct_trie_from_chars(
+def build_trie_from_chars(
     strings: Collection[str],
 ) -> Tuple[Trie, Sequence[int]]:
     trie = Trie.in_chars()
     node_ids = [trie.insert_chars(s) for s in strings]
     return trie, node_ids
 
 
-def construct_trie_from_bytes(
+def build_trie_from_bytes(
     strings: Collection[bytes],
 ) -> Tuple[Trie, Sequence[int]]:
     trie = Trie.in_bytes()
@@ -38,12 +38,12 @@ class SortResult:
 
 
 def sort_chars(strings: Collection[str]) -> SortResult:
-    trie, node_ids = construct_trie_from_chars(strings)
+    trie, node_ids = build_trie_from_chars(strings)
     return sort_seq_via_trie(trie, node_ids)
 
 
 def sort_bytes(strings: Collection[bytes]) -> SortResult:
-    trie, node_ids = construct_trie_from_bytes(strings)
+    trie, node_ids = build_trie_from_bytes(strings)
     return sort_seq_via_trie(trie, node_ids)
 
 

general_sam/vocab_prefix.py

@@ -15,8 +15,8 @@
 from .trie_utils import (
     CountInfo,
     SortResult,
-    construct_trie_from_bytes,
-    construct_trie_from_chars,
+    build_trie_from_bytes,
+    build_trie_from_chars,
     sort_bytes,
     sort_chars,
 )
@@ -53,17 +53,17 @@ def __init__(
 
         self.vocab_rev: Sequence[Union[str, bytes]] = list(s[::-1] for s in vocab)
 
-        sort_seq, construct_trie = {
-            VocabPrefixBytesOrChars.BYTES: (sort_bytes, construct_trie_from_bytes),
-            VocabPrefixBytesOrChars.CHARS: (sort_chars, construct_trie_from_chars),
+        sort_seq, trie_builder = {
+            VocabPrefixBytesOrChars.BYTES: (sort_bytes, build_trie_from_bytes),
+            VocabPrefixBytesOrChars.CHARS: (sort_chars, build_trie_from_chars),
         }[self.bytes_or_chars]
         self.vocab_sort_res = cast(SortResult, sort_seq(self.vocab))
         self.trie_rev, self.trie_rev_node_ids = cast(
             Tuple[Trie, Sequence[int]],
-            construct_trie(self.vocab_rev),
+            trie_builder(self.vocab_rev),
         )
 
-        self.sam_rev = GeneralSAM.construct_from_trie(self.trie_rev)
+        self.sam_rev = GeneralSAM.from_trie(self.trie_rev)
         self._gen_cnt_info_in_sam()
 
     @property

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "general_sam"
-requires-python = ">=3.7"
+requires-python = ">=3.8"
 classifiers = [
     "Programming Language :: Rust",
     "Programming Language :: Python :: Implementation :: CPython",

src/sam.rs

@@ -3,12 +3,16 @@ extern crate general_sam as general_sam_rs;
 use crate::trie::Trie;
 use crate::utils::{char_or_byte_type, for_both, ByteSide, CharSide};
 
-use general_sam_rs::{sam as sam_rs, trie as trie_rs, trie_alike::TravelEvent};
+use general_sam_rs::{
+    sam as sam_rs, trie as trie_rs, BTreeTransTable, BoxBisectTable, TransitionTable, TravelEvent,
+};
 use pyo3::{prelude::*, types::PyDict};
 use std::{str::from_utf8, sync::Arc};
 
-type RustGeneralSAM = char_or_byte_type!(sam_rs::GeneralSAM);
-type RustGeneralSAMState<'s> = char_or_byte_type!(sam_rs::GeneralSAMState; 's);
+type RustBoxBisectGeneralSAM<T> = sam_rs::GeneralSAM<BoxBisectTable<T>>;
+type RustBoxBisectGeneralSAMState<'s, T> = sam_rs::GeneralSAMState<'s, BoxBisectTable<T>>;
+type RustGeneralSAM = char_or_byte_type!(RustBoxBisectGeneralSAM);
+type RustGeneralSAMState<'s> = char_or_byte_type!(RustBoxBisectGeneralSAMState; 's);
 
 #[pyclass]
 pub struct GeneralSAM(pub Arc<RustGeneralSAM>);
@@ -56,7 +60,7 @@ impl GeneralSAMState {
         for_both!(self.get_state().as_ref(), state => {
             Python::with_gil(|py| {
                 if let Some(node) = state.get_node() {
-                    node.get_trans().clone().into_py(py)
+                    BTreeTransTable::from_kv_iter(node.get_trans().iter()).into_py(py)
                 } else {
                     PyDict::new(py).into_py(py)
                 }
@@ -215,27 +219,30 @@ impl GeneralSAMState {
 #[pymethods]
 impl GeneralSAM {
     #[staticmethod]
-    pub fn construct_from_chars(s: &str) -> Self {
+    pub fn from_chars(s: &str) -> Self {
         GeneralSAM(Arc::new(CharSide(
-            sam_rs::GeneralSAM::construct_from_chars(s.chars()),
+            sam_rs::GeneralSAM::<BTreeTransTable<_>>::from_chars(s.chars())
+                .alter_trans_table_into(),
         )))
     }
 
     #[staticmethod]
-    pub fn construct_from_bytes(s: &[u8]) -> Self {
+    pub fn from_bytes(s: &[u8]) -> Self {
         GeneralSAM(Arc::new(ByteSide(
-            sam_rs::GeneralSAM::construct_from_bytes(s),
+            sam_rs::GeneralSAM::<BTreeTransTable<_>>::from_bytes(s).alter_trans_table_into(),
         )))
     }
 
     #[staticmethod]
-    pub fn construct_from_trie(trie: &Trie) -> Self {
+    pub fn from_trie(trie: &Trie) -> Self {
         match trie.0.as_ref() {
             CharSide(trie_chars) => GeneralSAM(Arc::new(CharSide(
-                sam_rs::GeneralSAM::construct_from_trie(trie_chars.get_root_state()),
+                sam_rs::GeneralSAM::<BTreeTransTable<_>>::from_trie(trie_chars.get_root_state())
+                    .alter_trans_table_into(),
             ))),
             ByteSide(trie_bytes) => GeneralSAM(Arc::new(ByteSide(
-                sam_rs::GeneralSAM::construct_from_trie(trie_bytes.get_root_state()),
+                sam_rs::GeneralSAM::<BTreeTransTable<_>>::from_trie(trie_bytes.get_root_state())
+                    .alter_trans_table_into(),
             ))),
         }
     }

src/trie.rs

@@ -2,15 +2,14 @@ extern crate general_sam as general_sam_rs;
 
 use crate::utils::{char_or_byte_type, for_both, ByteSide, CharSide};
 
-use general_sam_rs::{
-    trie as trie_rs,
-    trie_alike::{TravelEvent, TrieNodeAlike},
-};
+use general_sam_rs::{trie as trie_rs, BTreeTransTable, TravelEvent, TrieNodeAlike};
 use pyo3::prelude::*;
 use std::{convert::Infallible, str::from_utf8};
 
-type RustTrie = char_or_byte_type!(trie_rs::Trie);
-type RustTrieNode = char_or_byte_type!(trie_rs::TrieNode);
+type RustBTreeTrie<T> = trie_rs::Trie<BTreeTransTable<T>>;
+type RustBTreeTrieNode<T> = trie_rs::TrieNode<BTreeTransTable<T>>;
+type RustTrie = char_or_byte_type!(RustBTreeTrie);
+type RustTrieNode = char_or_byte_type!(RustBTreeTrieNode);
 
 #[pyclass]
 pub struct Trie(pub RustTrie);

tests/test_general_sam.py

@@ -1,8 +1,8 @@
-from general_sam import GeneralSAM, GeneralSAMState, construct_trie_from_chars
+from general_sam import GeneralSAM, GeneralSAMState, build_trie_from_chars
 
 
 def test_bytes_abcbc():
-    sam = GeneralSAM.construct_from_bytes(b'abcbc')
+    sam = GeneralSAM.from_bytes(b'abcbc')
 
     state = sam.get_root_state()
     state.feed_bytes(b'cbc')
@@ -14,7 +14,7 @@ def test_bytes_abcbc():
 
 
 def test_chars_abcbc():
-    sam = GeneralSAM.construct_from_chars('abcbc')
+    sam = GeneralSAM.from_chars('abcbc')
     state = sam.get_root_state()
 
     state.feed_chars('b')
@@ -28,8 +28,8 @@ def test_chars_abcbc():
 
 
 def test_simple_sam_from_trie():
-    trie, _ = construct_trie_from_chars(['hello', 'Chielo'])
-    sam = GeneralSAM.construct_from_trie(trie)
+    trie, _ = build_trie_from_chars(['hello', 'Chielo'])
+    sam = GeneralSAM.from_trie(trie)
 
     def fetch_state(s: str) -> GeneralSAMState:
         state = sam.get_root_state()