ReForma 0.3__tar.gz → 0.4__tar.gz

{reforma-0.3 → reforma-0.4}/PKG-INFO

@@ -1,16 +1,19 @@
 Metadata-Version: 2.4
 Name: ReForma
-Version: 0.3
+Version: 0.4
 Summary: Python bindings for the RePA/ReForma probabilistic automaton tool
 Author-email: Joshua Dourado <joshuadourado@ua.pt>
 License: MIT
 Classifier: Programming Language :: Python :: 3
 Classifier: Operating System :: OS Independent
 Classifier: Topic :: Scientific/Engineering
-Requires-Python: >=3.10
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 Requires-Dist: networkx
 Requires-Dist: matplotlib
+Provides-Extra: data
+Requires-Dist: pandas; extra == "data"
+Requires-Dist: numpy; extra == "data"
 
 
 # ReForma — Reconfigurable Formal Automata in Python

{reforma-0.3 → reforma-0.4}/ReForma.egg-info/PKG-INFO

@@ -1,16 +1,19 @@
 Metadata-Version: 2.4
 Name: ReForma
-Version: 0.3
+Version: 0.4
 Summary: Python bindings for the RePA/ReForma probabilistic automaton tool
 Author-email: Joshua Dourado <joshuadourado@ua.pt>
 License: MIT
 Classifier: Programming Language :: Python :: 3
 Classifier: Operating System :: OS Independent
 Classifier: Topic :: Scientific/Engineering
-Requires-Python: >=3.10
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 Requires-Dist: networkx
 Requires-Dist: matplotlib
+Provides-Extra: data
+Requires-Dist: pandas; extra == "data"
+Requires-Dist: numpy; extra == "data"
 
 
 # ReForma — Reconfigurable Formal Automata in Python

reforma-0.4/ReForma.egg-info/requires.txt

@@ -0,0 +1,6 @@
+networkx
+matplotlib
+
+[data]
+pandas
+numpy

{reforma-0.3 → reforma-0.4}/pyproject.toml

@@ -4,10 +4,10 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ReForma"
-version = "0.3"
+version = "0.4"
 description = "Python bindings for the RePA/ReForma probabilistic automaton tool"
 readme = "README.md"
-requires-python = ">=3.10"
+requires-python = ">=3.9"
 license = { text = "MIT" }
 authors = [
     { name = "Joshua Dourado", email = "joshuadourado@ua.pt" }
@@ -22,6 +22,9 @@ dependencies = [
     "matplotlib"
 ]
 
+[project.optional-dependencies]
+data = ["pandas", "numpy"]
+
 [tool.setuptools]
 packages = ["reforma", "reforma.bin", "reforma.bin.js"]
 

{reforma-0.3 → reforma-0.4}/reforma/__init__.py

@@ -1,19 +1,19 @@
-"""
-reforma - Python bindings for the RePA/reforma tool.
-
-The JAR is bundled inside the package. Usage:
-
-    from reforma import ReForma
-
-    model = ReForma()
-
-    state = model.load_file("my_model.r")
-    state = model.step("go_work")
-    result = model.check_pdl("Home", "{P=?[F Office]}")
-"""
-
-from .client import ReForma
-from .model import ReFormaModel, Transition, SimulationState
-
-__all__ = ["ReForma", "ReFormaModel", "Transition", "SimulationState"]
-__version__ = "0.2.0"
+"""
+reforma - Python bindings for the RePA/reforma tool.
+
+The JAR is bundled inside the package. Usage:
+
+    from reforma import ReForma
+
+    model = ReForma()
+
+    state = model.load_file("my_model.r")
+    state = model.step("go_work")
+    result = model.check_pdl("Home", "{P=?[F Office]}")
+"""
+
+from .client import ReForma
+from .model import ReFormaModel, Transition, SimulationState
+
+__all__ = ["ReForma", "ReFormaModel", "Transition", "SimulationState"]
+__version__ = "0.4"

{reforma-0.3 → reforma-0.4}/reforma/client.py

@@ -81,19 +81,20 @@ class ReForma:
 
     
     def create_from_dataframe(
-        self, 
-        df, 
-        session_col: str = 'user_session', 
-        event_col: str = 'event_type', 
+        self,
+        df,
+        session_col: str = 'user_session',
+        event_col: str = 'event_type',
         sub_event_col: Optional[str] = None,
-        time_col: str = 'event_time', 
+        time_col: str = 'event_time',
         model_name: str = "MinedModel",
         save_model_path: Optional[str] = None,
-        save_traces_path: Optional[str] = None
+        save_traces_path: Optional[str] = None,
+        initial_weights: str = "frequency"
     ) -> list[list[str]]:
         """
         Discovers the RePA model directly from a Pandas DataFrame.
-        
+
         :param df: Pandas DataFrame containing the dataset.
         :param session_col: Column name identifying user sessions.
         :param event_col: Column name containing the action/event.
@@ -102,34 +103,85 @@ class ReForma:
         :param model_name: Name to give the automaton.
         :param save_model_path: If set, saves the generated .rta code to this file path.
         :param save_traces_path: If set, saves the session logs (.txt) to this file path.
+        :param initial_weights: "frequency" (default) writes the observed transition frequencies (the maximum
+            likelihood estimate) as weights; "uniform" leaves the weights out, so every state starts uniform.
         :return: A list of sessions (each session is a list of transition IDs).
         """
         try:
             import pandas as pd
+            import numpy as np
             import re
         except ImportError:
             raise RuntimeError("To use process mining you need to install: pip install pandas")
-        
-        def sanitize(text):
-            return re.sub(r'[^a-zA-Z0-9_]', '_', str(text))
-
-        df_work = df.dropna(subset=[session_col]).copy()
-        df_work = df_work.sort_values(by=[session_col, time_col])
-
-        if sub_event_col and sub_event_col in df_work.columns:
-            df_work[sub_event_col] = df_work[sub_event_col].fillna('other').astype(str)
-            parsed_sub = df_work[sub_event_col].apply(lambda x: str(x).split('.')[-1])
-            df_work['__target_event'] = df_work[event_col].astype(str) + "_" + parsed_sub
+        if initial_weights not in ("frequency", "uniform"):
+            raise ValueError("initial_weights must be 'frequency' or 'uniform'")
+
+        has_sub = bool(sub_event_col) and sub_event_col in df.columns
+        cols = [session_col, time_col, event_col] + ([sub_event_col] if has_sub else [])
+        df_work = df.loc[df[session_col].notna(), cols]
+        # stable sort: events with the same timestamp keep the order of the log
+        df_work = df_work.sort_values(by=[session_col, time_col], kind="mergesort")
+
+        # Every row gets the integer code of its (composite) event; all the work below is done on these codes.
+        ev = df_work[event_col].astype("category")
+        ev_codes = ev.cat.codes.to_numpy().astype(np.int64)
+        ev_names = [str(c) for c in ev.cat.categories]
+        if has_sub:
+            sub = df_work[sub_event_col].astype("category")
+            sub_names = [str(c) for c in sub.cat.categories] + ["other"]          # missing sub-events -> "other"
+            sub_codes = sub.cat.codes.to_numpy().astype(np.int64)
+            sub_codes[sub_codes < 0] = len(sub_names) - 1
+            # the last component of a category ("electronics.smartphone" -> "smartphone") is used, unless two
+            # different categories share it: those keep their full path
+            by_leaf: dict = {}
+            for c in sub_names:
+                by_leaf.setdefault(c.split('.')[-1], set()).add(c)
+            short = [c.split('.')[-1] if len(by_leaf[c.split('.')[-1]]) == 1 else c for c in sub_names]
+            combo = ev_codes * len(sub_names) + sub_codes
+            uniq, raw_codes = np.unique(combo, return_inverse=True)
+            raw_names = [f"{ev_names[u // len(sub_names)]}_{short[u % len(sub_names)]}" for u in uniq]
         else:
-            df_work['__target_event'] = df_work[event_col].astype(str)
-
-        df_work['next_event'] = df_work.groupby(session_col)['__target_event'].shift(-1).fillna('exit')
-
-        df_work['clean_event'] = df_work['__target_event'].apply(sanitize)
-        df_work['clean_next']  = df_work['next_event'].apply(sanitize)
-
-        first_events = df_work.groupby(session_col)['clean_event'].first().value_counts()
-        transitions = df_work.groupby(['clean_event', 'clean_next']).size().reset_index(name='count')
+            raw_codes, raw_names = ev_codes, ev_names
+        raw_codes = np.asarray(raw_codes, dtype=np.int64)
+
+        # One Re-Lang name per distinct event, distinct from each other, from the artificial states and from keywords.
+        reserved = {"Start", "exit", "init", "training", "calibration", "paradigm", "name", "int", "float", "bool",
+                    "dyn", "def", "aut", "if", "then", "disabled", "true", "false", "return", "print", "foreach",
+                    "in", "AND", "OR", "laplace", "aggregation", "arith", "prod", "max", "min", "geom"}
+        clean = [""] * len(raw_names)
+        used = set(reserved)
+        for i in sorted(range(len(raw_names)), key=lambda i: raw_names[i]):
+            base = re.sub(r'[^a-zA-Z0-9_]', '_', raw_names[i]).strip('_') or "event"
+            if base[0].isdigit() or base in reserved:
+                base = "ev_" + base
+            candidate, k = base, 2
+            while candidate in used:
+                candidate, k = f"{base}_{k}", k + 1
+            used.add(candidate)
+            clean[i] = candidate
+        K = len(clean)
+        names = clean + ["exit"]                                                # index K is the artificial exit
+
+        # sessions are contiguous after the sort
+        sess_codes = pd.factorize(df_work[session_col], sort=False)[0]
+        new_sess = np.empty(len(sess_codes), dtype=bool)
+        new_sess[:1] = True
+        new_sess[1:] = sess_codes[1:] != sess_codes[:-1]
+        is_last = np.empty_like(new_sess)
+        is_last[:-1] = new_sess[1:]
+        is_last[-1:] = True
+        nxt = np.empty_like(raw_codes)
+        nxt[:-1] = raw_codes[1:]
+        nxt[is_last] = K
+
+        firsts = raw_codes[new_sess]
+        first_counts = np.bincount(firsts, minlength=K)
+        pair = raw_codes * (K + 1) + nxt
+        pair_counts = np.bincount(pair, minlength=K * (K + 1))
+        out_totals = pair_counts.reshape(K, K + 1).sum(axis=1)
+
+        def weight(count, total) -> str:
+            return f" ({count / total:.6f})" if initial_weights == "frequency" else ""
 
         rta_output = [
             f"name {model_name};",
@@ -139,44 +191,33 @@ class ReForma:
             "init Start;\n"
         ]
 
-        mapping = {}
         edge_counter = 1
-
-        for event_type, count in first_events.items():
+        n_sessions = int(first_counts.sum())
+        start_label = np.empty(K, dtype=object)
+        for i in sorted((i for i in range(K) if first_counts[i] > 0), key=lambda i: (-first_counts[i], names[i])):
             label_id = f"e{edge_counter}"
-            rta_output.append(f"Start -enter_{event_type}-> {event_type} : {label_id}")
-            mapping[('Start', event_type)] = label_id
+            rta_output.append(f"Start -enter_{names[i]}-> {names[i]} : {label_id}{weight(first_counts[i], n_sessions)}")
+            start_label[i] = label_id
             edge_counter += 1
 
         rta_output.append("")
 
-        for source in transitions['clean_event'].unique():
-            df_source = transitions[transitions['clean_event'] == source]
-            
-            for _, row in df_source.iterrows():
-                src, tgt = row['clean_event'], row['clean_next']
-                label_id = f"e{edge_counter}"
-                
-                rta_output.append(f"{src} -{tgt}-> {tgt} : {label_id}")
-                mapping[(src, tgt)] = label_id
-                edge_counter += 1
+        pair_label = np.empty(K * (K + 1), dtype=object)
+        observed = [p for p in np.flatnonzero(pair_counts)]
+        for p in sorted(observed, key=lambda p: (names[p // (K + 1)], names[p % (K + 1)])):
+            src, tgt = names[p // (K + 1)], names[p % (K + 1)]
+            label_id = f"e{edge_counter}"
+            rta_output.append(f"{src} -{tgt}-> {tgt} : {label_id}{weight(pair_counts[p], out_totals[p // (K + 1)])}")
+            pair_label[p] = label_id
+            edge_counter += 1
 
         loop_edge_id = f"e{edge_counter}"
         rta_output.append("\n// Loop at the final state to avoid deadlock in PRISM")
         rta_output.append(f"exit -loop-> exit : {loop_edge_id} (1.0000)")
 
-        df_work['edge_tuple'] = list(zip(df_work['clean_event'], df_work['clean_next']))
-        df_work['edge_id'] = df_work['edge_tuple'].map(mapping)
-
-        first_in_session = df_work.groupby(session_col)['clean_event'].first()
-        start_edges = first_in_session.apply(lambda e: mapping.get(('Start', e)))
-        internal_edges = df_work.groupby(session_col)['edge_id'].apply(list)
-
-        traces = []
-        for session_id in internal_edges.index:
-            start_edge = start_edges[session_id]
-            path = [start_edge] + [e for e in internal_edges[session_id] if pd.notna(e)]
-            traces.append(path)
+        row_labels = pair_label[pair]
+        starts = np.flatnonzero(new_sess)
+        traces = [[start_label[f]] + chunk.tolist() for f, chunk in zip(firsts, np.split(row_labels, starts[1:]))]
 
         full_source = "\n".join(rta_output)
         self.load(full_source, name=model_name)
@@ -184,10 +225,12 @@ class ReForma:
         if save_model_path:
             with open(save_model_path, "w", encoding="utf-8") as f:
                 f.write(full_source)
-        
+
         if save_traces_path:
             with open(save_traces_path, "w", encoding="utf-8") as f:
-                f.write("\n".join(",".join(t) for t in traces))
+                for t in traces:
+                    f.write(",".join(t))
+                    f.write("\n")
 
         return traces
 
@@ -771,6 +814,11 @@ class ReForma:
         self._require_model()
         log_lines = [",".join(s) for s in sessions]
         updated_source = self._bridge.train(self._model.source, log_lines)
+        # the engine reports events that could not be replayed (unknown label, or not enabled at that point)
+        report = next((l for l in getattr(self._bridge, "last_stdout", "").splitlines() if "Warning:" in l), None)
+        if report:
+            import warnings
+            warnings.warn(report.split("Training completed")[-1].strip(), RuntimeWarning, stacklevel=2)
         self._model = ReFormaModel.from_string(updated_source, self._model.name)
         self._current_source = updated_source
         self._history = []
@@ -807,6 +855,11 @@ class ReForma:
         return self._bridge.get_prism(self._model.source)
 
 
+    def export_mcrl2(self) -> str:
+        """Export to mCRL2."""
+        self._require_model()
+        return self._bridge.get_mcrl2(self._model.source)
+
     def export_glts(self) -> str:
         """Translate to GLTS (imperative) format."""
         self._require_model()

{reforma-0.3 → reforma-0.4}/reforma/jar_bridge.py

@@ -141,6 +141,9 @@ class JarBridge:
     def get_prism(self, source: str) -> str:
         return self._run_with_tempfile("-prism", source)
 
+    def get_mcrl2(self, source: str) -> str:
+        return self._run_with_tempfile("-mcrl2", source)
+
     def get_cytoscape(self, source: str, history: Optional[list[str]] = None) -> str:
         extra = [",".join(history)] if history else []
         return self._run_with_tempfile("-cytoscape", source, extra_args=extra)
@@ -193,6 +196,7 @@ class JarBridge:
             raise JarError(
                 f"JAR exited {result.returncode}:\n{result.stderr.strip()}"
             )
+        self.last_stdout = result.stdout or ""
         out_path = args[-1]
         if not os.path.exists(out_path):
             raise JarError(

{reforma-0.3 → reforma-0.4}/reforma/model.py

@@ -88,7 +88,8 @@ class ReFormaModel:
     def from_file(cls, path: str) -> "ReFormaModel":
         with open(path, "r", encoding="utf-8") as f:
             source = f.read()
-        name = path.split("/")[-1].replace(".r", "")
+        import os
+        name = os.path.splitext(os.path.basename(path))[0]
         return cls(source=source, name=name)
 
     @classmethod

{reforma-0.3 → reforma-0.4}/tests/test_reforma.py

@@ -5,9 +5,9 @@ tests/test_reforma.py — full test suite (mocked, no real JAR needed).
 import pytest
 from unittest.mock import MagicMock, patch
 
-from reforma import reforma
+from reforma import ReForma as reforma
 
-from reforma.model import reformaModel, Transition, SimulationState
+from reforma.model import ReFormaModel as reformaModel, Transition, SimulationState
 from reforma.jar_bridge import JarBridge, JarError
 from reforma.client import _parse_pdl_result
 

reforma-0.3/ReForma.egg-info/requires.txt

@@ -1,2 +0,0 @@
-networkx
-matplotlib