struct_automaton 0.1.0__tar.gz

struct_automaton-0.1.0/Cargo.lock

@@ -0,0 +1,132 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "heck"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
+
+[[package]]
+name = "libc"
+version = "0.2.186"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "68ab91017fe16c622486840e4c83c9a37afeff978bd239b5293d61ece587de66"
+
+[[package]]
+name = "once_cell"
+version = "1.21.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
+
+[[package]]
+name = "portable-atomic"
+version = "1.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c33a9471896f1c69cecef8d20cbe2f7accd12527ce60845ff44c153bb2a21b49"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.106"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "pyo3"
+version = "0.29.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cd274650b21d4bfc26a0a47587962c1edb425f69287324355cd040c3ea66071c"
+dependencies = [
+ "libc",
+ "once_cell",
+ "portable-atomic",
+ "pyo3-build-config",
+ "pyo3-ffi",
+ "pyo3-macros",
+]
+
+[[package]]
+name = "pyo3-build-config"
+version = "0.29.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c5e2a7d2f0d013342f295c048ad19237add5154a55b1c5a254c0ec93d4109078"
+dependencies = [
+ "target-lexicon",
+]
+
+[[package]]
+name = "pyo3-ffi"
+version = "0.29.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ca85c467da1bbc8d866eea5deff9cf29ea5f7785054a17da36e65bda9c05845b"
+dependencies = [
+ "libc",
+ "pyo3-build-config",
+]
+
+[[package]]
+name = "pyo3-macros"
+version = "0.29.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ac53762fd065daa3194dd09337a38bd793a188100fd1a9304c4ab312d901771"
+dependencies = [
+ "proc-macro2",
+ "pyo3-macros-backend",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "pyo3-macros-backend"
+version = "0.29.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4ca3a1557399783172dc5bf39cfca835157732532cba56b71d2292161e53b362"
+dependencies = [
+ "heck",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.46"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dfbc457d0c7a0759a614551b11a6409e5951f6c7537be1f1b7682b9ae9230368"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "struct_automaton"
+version = "0.1.0"
+dependencies = [
+ "pyo3",
+]
+
+[[package]]
+name = "syn"
+version = "2.0.118"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1b9ae57f904213ebb649ce6895b8a66c66f0203b9319718f69a5612a065b1422"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "target-lexicon"
+version = "0.13.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "adb6935a6f5c20170eeceb1a3835a49e12e19d792f6dd344ccc76a985ca5a6ca"
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"

struct_automaton-0.1.0/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "struct_automaton"
+version = "0.1.0"
+edition = "2024"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+[lib]
+name = "struct_automaton"
+crate-type = ["cdylib"]
+
+[dependencies]
+pyo3 = "0.29.0"

struct_automaton-0.1.0/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: struct_automaton
+Version: 0.1.0
+Classifier: Programming Language :: Rust
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Summary: A small example package
+Author-email: Intplex <gabriel08romao0@gmail.com>
+Requires-Python: >=3.8

struct_automaton-0.1.0/pyproject.toml

@@ -0,0 +1,21 @@
+[build-system]
+requires = ["maturin>=1.14,<2.0"]
+build-backend = "maturin"
+
+[project]
+name = "struct_automaton"
+authors = [
+  { name="Intplex", email="gabriel08romao0@gmail.com" },
+]
+description = "A small example package"
+requires-python = ">=3.8"
+classifiers = [
+    "Programming Language :: Rust",
+    "Programming Language :: Python :: Implementation :: CPython",
+    "Programming Language :: Python :: Implementation :: PyPy",
+]
+dynamic = ["version"]
+
+[tool.maturin]
+# Força o Maturin a aplicar as regras do auditwheel e gerar tags válidas para o PyPI
+compatibility = "pypi" 

struct_automaton-0.1.0/src/lib.rs

@@ -0,0 +1,312 @@
+use pyo3::prelude::*;
+use pyo3::exceptions::{PyValueError, PyTypeError};
+use pyo3::types::{PyAnyMethods, PyList, PyTuple};
+// Importação obrigatória nas novas versões para expor o método de conversão limpa .into_py_any()
+use pyo3::conversion::IntoPyObjectExt; 
+use std::collections::{HashMap, HashSet};
+
+#[pyclass]
+struct AutomatonStruct {
+    states: HashSet<String>,
+    alphabet: HashSet<String>,
+    data: Py<PyAny>,
+    initial: String,
+    current_state: String, 
+    finals: HashSet<String>,
+    delta: HashMap<(String, char), String>,
+    history: Vec<(String, Py<PyAny>)>, 
+}
+
+#[pymethods]
+impl AutomatonStruct {
+    #[new]
+    fn new(py: Python<'_>, states: HashSet<String>, alphabet: HashSet<String>, initial: String, finals: HashSet<String>) -> Self {
+        AutomatonStruct {
+            states,
+            alphabet,
+            initial: initial.clone(),
+            current_state: initial,
+            finals,
+            delta: HashMap::new(),
+            data: py.None(),
+            history: Vec::new(),
+        }
+    }
+
+    fn add_transition(&mut self, of: String, with: char, for_: String) -> PyResult<()> {
+        if !self.states.contains(&of) || !self.states.contains(&for_) {
+            return Err(PyValueError::new_err(
+                "Erro: Um ou ambos os estados nao pertencem ao automato."
+            ));
+        }
+
+        if !self.alphabet.contains(&with.to_string()) {
+            return Err(PyValueError::new_err(format!(
+                "Erro: O simbolo '{}' nao pertence ao alfabeto do automato.", with
+            )));
+        }
+
+        if self.delta.contains_key(&(of.clone(), with)) {
+            return Err(PyValueError::new_err(format!(
+                "Erro: O estado '{}' ja possui uma transicao definida para o simbolo '{}'.", 
+                of, with
+            )));
+        }
+
+        self.delta.insert((of, with), for_);
+        Ok(())
+    }
+
+    fn accept(&self, st: String) -> bool {
+        let mut now_state = self.initial.clone();
+
+        for caracter in st.chars() {
+            if let Some(next) = self.delta.get(&(now_state.clone(), caracter)) {
+                now_state = next.clone();
+            } else {
+                return false; 
+            }
+        }
+        self.finals.contains(&now_state)
+    }
+
+    // --- MÉTODOS DE MANIPULAÇÃO DE DADOS (CONTEXTO) ---
+
+    fn transform_data(&mut self, py: Python<'_>, data_type_result: String, operation: String, assert_val: &Bound<'_, PyAny>) -> PyResult<()> {
+        let current_bound = self.data.bind(py);
+
+        if operation == "clear" {
+            self.data = py.None();
+            return Ok(());
+        }
+
+        if data_type_result == "str" {
+            let mut texto_base = match current_bound.extract::<String>() {
+                Ok(t) => t,
+                Err(_) => current_bound.to_string(),
+            };
+
+            if operation == "concat" {
+                let sufixo = assert_val.extract::<String>()?;
+                texto_base.push_str(&sufixo);
+            }
+            
+            // RESOLUÇÃO: O método do PyO3 converte e entrega diretamente o Py<PyAny>
+            self.data = texto_base.into_py_any(py)?;
+
+        } else if data_type_result == "int" {
+            let mut numero_base = current_bound.extract::<i64>().unwrap_or(0);
+
+            if operation == "add" {
+                let valor_somar = assert_val.extract::<i64>()?;
+                numero_base += valor_somar;
+            }
+
+            // RESOLUÇÃO: O método do PyO3 converte e entrega diretamente o Py<PyAny>
+            self.data = numero_base.into_py_any(py)?;
+        } else {
+            return Err(PyTypeError::new_err("Tipo de dado nao suportado. Use 'str' ou 'int'."));
+        }
+
+        Ok(())
+    }
+
+    fn update_context(&mut self, new_data: &Bound<'_, PyAny>) -> PyResult<()> {
+        self.data = new_data.clone().unbind();
+        Ok(())
+    }
+
+    fn get_context_type(&self, py: Python<'_>) -> String {
+        match self.data.bind(py).get_type().name() {
+            Ok(n) => n.to_string(),
+            Err(_) => String::from("unknown"),
+        }
+    }
+
+    #[getter]
+    fn data(&self, py: Python<'_>) -> Py<PyAny> {
+        self.data.clone_ref(py)
+    }
+
+    // --- MÉTODOS DE CONTROLE DO AUTÔMATO ---
+
+    fn step(&mut self, py: Python<'_>, symbol: char) -> PyResult<bool> {
+        self.history.push((self.current_state.clone(), self.data.clone_ref(py)));
+
+        if let Some(next_state) = self.delta.get(&(self.current_state.clone(), symbol)) {
+            self.current_state = next_state.clone();
+            Ok(true)
+        } else {
+            Ok(false) 
+        }
+    }
+
+    fn force_state(&mut self, py: Python<'_>, state_id: String) -> PyResult<()> {
+        if !self.states.contains(&state_id) {
+            return Err(PyValueError::new_err("O estado destino nao existe no automato."));
+        }
+        self.history.push((self.current_state.clone(), self.data.clone_ref(py)));
+        self.current_state = state_id;
+        Ok(())
+    }
+
+    fn undo(&mut self) -> PyResult<bool> {
+        if let Some((previous_state, previous_data)) = self.history.pop() {
+            self.current_state = previous_state;
+            self.data = previous_data;
+            Ok(true)
+        } else {
+            Ok(false)
+        }
+    }
+
+    fn reset(&mut self, py: Python<'_>) {
+        self.current_state = self.initial.clone();
+        self.data = py.None();
+        self.history.clear();
+    }
+
+    fn is_accepted(&self) -> bool {
+        self.finals.contains(&self.current_state)
+    }
+
+    #[getter]
+    fn current_state(&self) -> String {
+        self.current_state.clone()
+    }
+
+    // --- NOVOS MÉTODOS DE CONSULTA E CONTROLE DO AUTÔMATO ---
+
+    fn remove_transition(&mut self, of: String, with: char) -> PyResult<()> {
+        if self.delta.remove(&(of.clone(), with)).is_none() {
+            return Err(PyValueError::new_err(format!(
+                "Erro: Nao existe transicao definida para o estado '{}' com o simbolo '{}'.",
+                of, with
+            )));
+        }
+        Ok(())
+    }
+
+    fn has_transition(&self, of: String, with: char) -> bool {
+        self.delta.contains_key(&(of, with))
+    }
+
+    fn is_final(&self, state: String) -> bool {
+        self.finals.contains(&state)
+    }
+
+    fn get_states(&self) -> Vec<String> {
+        let mut v: Vec<String> = self.states.iter().cloned().collect();
+        v.sort();
+        v
+    }
+
+    fn get_alphabet(&self) -> Vec<String> {
+        let mut v: Vec<String> = self.alphabet.iter().cloned().collect();
+        v.sort();
+        v
+    }
+
+    fn get_finals(&self) -> Vec<String> {
+        let mut v: Vec<String> = self.finals.iter().cloned().collect();
+        v.sort();
+        v
+    }
+
+    #[getter]
+    fn initial_state(&self) -> String {
+        self.initial.clone()
+    }
+
+    /// Retorna todas as transições como tuplas (origem, símbolo, destino).
+    fn get_transitions(&self) -> Vec<(String, char, String)> {
+        self.delta
+            .iter()
+            .map(|((of, sym), to)| (of.clone(), *sym, to.clone()))
+            .collect()
+    }
+
+    /// Retorna os símbolos que possuem transição definida a partir do estado atual.
+    fn available_symbols(&self) -> Vec<char> {
+        let mut v: Vec<char> = self
+            .delta
+            .keys()
+            .filter(|(of, _)| *of == self.current_state)
+            .map(|(_, sym)| *sym)
+            .collect();
+        v.sort();
+        v
+    }
+
+    /// Simula o consumo de uma cadeia a partir do estado atual SEM alterar o estado
+    /// do autômato, retornando o caminho de estados percorrido. Falha se, em algum
+    /// ponto, não houver transição definida para o símbolo lido.
+    fn simulate(&self, input: String) -> PyResult<Vec<String>> {
+        let mut path = vec![self.current_state.clone()];
+        let mut now_state = self.current_state.clone();
+
+        for caracter in input.chars() {
+            match self.delta.get(&(now_state.clone(), caracter)) {
+                Some(next) => {
+                    now_state = next.clone();
+                    path.push(now_state.clone());
+                }
+                None => {
+                    return Err(PyValueError::new_err(format!(
+                        "Erro: Nao ha transicao definida a partir do estado '{}' com o simbolo '{}'.",
+                        now_state, caracter
+                    )));
+                }
+            }
+        }
+        Ok(path)
+    }
+
+    // --- NOVOS MÉTODOS DE CONTROLE DE DADOS (CONTEXTO) ---
+
+    /// Substitui o dado de contexto diretamente (alias explícito de update_context).
+    fn set_data(&mut self, new_data: &Bound<'_, PyAny>) -> PyResult<()> {
+        self.update_context(new_data)
+    }
+
+    /// Zera o dado de contexto, sem afetar o estado atual do autômato.
+    fn clear_data(&mut self, py: Python<'_>) {
+        self.data = py.None();
+    }
+
+    /// Limpa o histórico de (estado, dado) acumulado, sem alterar estado ou dado atuais.
+    fn clear_history(&mut self) {
+        self.history.clear();
+    }
+
+    /// Quantidade de entradas atualmente registradas no histórico.
+    fn history_len(&self) -> usize {
+        self.history.len()
+    }
+
+    /// Observa a última entrada do histórico (estado, dado) sem removê-la.
+    fn peek_history(&self, py: Python<'_>) -> Option<(String, Py<PyAny>)> {
+        self.history
+            .last()
+            .map(|(state, data)| (state.clone(), data.clone_ref(py)))
+    }
+
+    fn get_history(&self, py: Python<'_>) -> PyResult<Py<PyList>> {
+        let list = PyList::empty(py);
+        for (state, data) in &self.history {
+            // RESOLUÇÃO: Converte a String nativa em objeto genérico do Python e anexa de forma limpa na tupla
+            let py_state = state.clone().into_py_any(py)?;
+            let py_data = data.clone_ref(py);
+
+            let tuple = PyTuple::new(py, &[py_state, py_data])?;
+            list.append(tuple)?;
+        }
+        Ok(list.unbind())
+    }
+}
+
+#[pymodule]
+fn struct_automaton(m: &Bound<'_, PyModule>) -> PyResult<()> {
+    m.add_class::<AutomatonStruct>()?;
+    Ok(())
+}