process-intelligence 0.1.0__tar.gz

process_intelligence-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Process Intelligence Research
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

process_intelligence-0.1.0/PKG-INFO

@@ -0,0 +1,12 @@
+Metadata-Version: 2.4
+Name: process-intelligence
+Version: 0.1.0
+Summary: A sample process intelligence Python project.
+Requires-Python: >=3.10
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Dynamic: license-file
+Dynamic: provides-extra
+Dynamic: requires-python
+Dynamic: summary

process_intelligence-0.1.0/README.md

@@ -0,0 +1,2 @@
+# test-dev
+Random description, bla bla bla

process_intelligence-0.1.0/process_intelligence.egg-info/PKG-INFO

@@ -0,0 +1,12 @@
+Metadata-Version: 2.4
+Name: process-intelligence
+Version: 0.1.0
+Summary: A sample process intelligence Python project.
+Requires-Python: >=3.10
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Dynamic: license-file
+Dynamic: provides-extra
+Dynamic: requires-python
+Dynamic: summary

process_intelligence-0.1.0/process_intelligence.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+LICENSE
+README.md
+setup.py
+process_intelligence.egg-info/PKG-INFO
+process_intelligence.egg-info/SOURCES.txt
+process_intelligence.egg-info/dependency_links.txt
+process_intelligence.egg-info/requires.txt
+process_intelligence.egg-info/top_level.txt
+src/__init__.py
+src/config.py
+src/models.py
+tests/test_helpers.py
+tests/test_models.py
+utils/__init__.py
+utils/helpers.py
+utils/logger.py

process_intelligence-0.1.0/process_intelligence.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

process_intelligence-0.1.0/process_intelligence.egg-info/requires.txt

@@ -0,0 +1,3 @@
+
+[dev]
+pytest>=7.0

process_intelligence-0.1.0/process_intelligence.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+src
+utils

process_intelligence-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

process_intelligence-0.1.0/setup.py

@@ -0,0 +1,13 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="process-intelligence",
+    version="0.1.0",
+    description="A sample process intelligence Python project.",
+    packages=find_packages(exclude=["tests*"]),
+    python_requires=">=3.10",
+    install_requires=[],
+    extras_require={
+        "dev": ["pytest>=7.0"],
+    },
+)

process_intelligence-0.1.0/src/__init__.py

@@ -0,0 +1 @@
+# src package

process_intelligence-0.1.0/src/config.py

@@ -0,0 +1,10 @@
+"""Application configuration constants."""
+
+APP_NAME = "process-intelligence"
+VERSION = "0.1.0"
+DEBUG = False
+
+DATABASE_URL = "sqlite:///data/app.db"
+LOG_LEVEL = "INFO"
+MAX_RETRIES = 3
+TIMEOUT_SECONDS = 30

process_intelligence-0.1.0/src/models.py

@@ -0,0 +1,68 @@
+"""Data models for the application."""
+
+from dataclasses import dataclass, field
+from typing import List, Optional
+from datetime import datetime
+
+
+@dataclass
+class Event:
+    """Represents a process event."""
+
+    event_id: str
+    name: str
+    timestamp: datetime
+    resource: Optional[str] = None
+    attributes: dict = field(default_factory=dict)
+
+    def to_dict(self) -> dict:
+        return {
+            "event_id": self.event_id,
+            "name": self.name,
+            "timestamp": self.timestamp.isoformat(),
+            "resource": self.resource,
+            "attributes": self.attributes,
+        }
+
+
+@dataclass
+class Case:
+    """Represents a process case (trace)."""
+
+    case_id: str
+    events: List[Event] = field(default_factory=list)
+
+    def add_event(self, event: Event) -> None:
+        self.events.append(event)
+
+    @property
+    def duration(self) -> Optional[float]:
+        if len(self.events) < 2:
+            return None
+        start = min(e.timestamp for e in self.events)
+        end = max(e.timestamp for e in self.events)
+        return (end - start).total_seconds()
+
+    def __len__(self) -> int:
+        return len(self.events)
+
+
+@dataclass
+class ProcessLog:
+    """Collection of cases forming a process event log."""
+
+    log_id: str
+    cases: List[Case] = field(default_factory=list)
+
+    def add_case(self, case: Case) -> None:
+        self.cases.append(case)
+
+    @property
+    def num_events(self) -> int:
+        return sum(len(c) for c in self.cases)
+
+    def get_case(self, case_id: str) -> Optional[Case]:
+        for case in self.cases:
+            if case.case_id == case_id:
+                return case
+        return None

process_intelligence-0.1.0/tests/test_helpers.py

@@ -0,0 +1,62 @@
+"""Tests for utils.helpers."""
+
+import pytest
+from utils.helpers import generate_id, format_duration, flatten, compute_checksum, chunk_list
+
+
+class TestGenerateId:
+    def test_returns_string(self):
+        assert isinstance(generate_id(), str)
+
+    def test_prefix_included(self):
+        uid = generate_id("evt")
+        assert uid.startswith("evt-")
+
+    def test_unique_ids(self):
+        ids = {generate_id() for _ in range(100)}
+        assert len(ids) == 100
+
+
+class TestFormatDuration:
+    def test_seconds_only(self):
+        assert format_duration(45.0) == "45.0s"
+
+    def test_minutes_and_seconds(self):
+        assert format_duration(125.0) == "2m 5s"
+
+    def test_hours_and_minutes(self):
+        assert format_duration(3661.0) == "1h 1m"
+
+
+class TestFlatten:
+    def test_already_flat(self):
+        assert flatten([1, 2, 3]) == [1, 2, 3]
+
+    def test_nested(self):
+        assert flatten([[1, 2], [3, [4, 5]]]) == [1, 2, 3, 4, 5]
+
+    def test_empty(self):
+        assert flatten([]) == []
+
+
+class TestComputeChecksum:
+    def test_deterministic(self):
+        assert compute_checksum("hello") == compute_checksum("hello")
+
+    def test_different_inputs(self):
+        assert compute_checksum("foo") != compute_checksum("bar")
+
+    def test_length(self):
+        assert len(compute_checksum("test")) == 64
+
+
+class TestChunkList:
+    def test_even_split(self):
+        assert chunk_list([1, 2, 3, 4], 2) == [[1, 2], [3, 4]]
+
+    def test_uneven_split(self):
+        assert chunk_list([1, 2, 3], 2) == [[1, 2], [3]]
+
+    def test_invalid_size(self):
+        with pytest.raises(ValueError):
+            chunk_list([1, 2], 0)

process_intelligence-0.1.0/tests/test_models.py

@@ -0,0 +1,65 @@
+"""Tests for src.models."""
+
+import pytest
+from datetime import datetime, timedelta
+from src.models import Event, Case, ProcessLog
+
+
+def make_event(name: str, offset_hours: int = 0) -> Event:
+    return Event(
+        event_id=f"evt-{offset_hours}",
+        name=name,
+        timestamp=datetime(2024, 1, 1, offset_hours),
+        resource="Alice",
+    )
+
+
+class TestEvent:
+    def test_to_dict_keys(self):
+        event = make_event("Start", 0)
+        d = event.to_dict()
+        assert set(d.keys()) == {"event_id", "name", "timestamp", "resource", "attributes"}
+
+    def test_to_dict_timestamp_is_string(self):
+        event = make_event("Start", 1)
+        assert isinstance(event.to_dict()["timestamp"], str)
+
+
+class TestCase:
+    def test_add_event_increases_length(self):
+        case = Case(case_id="case-001")
+        assert len(case) == 0
+        case.add_event(make_event("A", 0))
+        assert len(case) == 1
+
+    def test_duration_none_for_single_event(self):
+        case = Case(case_id="case-002")
+        case.add_event(make_event("A", 0))
+        assert case.duration is None
+
+    def test_duration_calculated_correctly(self):
+        case = Case(case_id="case-003")
+        case.add_event(make_event("A", 0))
+        case.add_event(make_event("B", 2))
+        assert case.duration == pytest.approx(2 * 3600)
+
+
+class TestProcessLog:
+    def test_num_events(self):
+        log = ProcessLog(log_id="log-001")
+        for i in range(3):
+            case = Case(case_id=f"case-{i}")
+            case.add_event(make_event("X", i))
+            case.add_event(make_event("Y", i + 1))
+            log.add_case(case)
+        assert log.num_events == 6
+
+    def test_get_case_existing(self):
+        log = ProcessLog(log_id="log-002")
+        case = Case(case_id="target")
+        log.add_case(case)
+        assert log.get_case("target") is case
+
+    def test_get_case_missing(self):
+        log = ProcessLog(log_id="log-003")
+        assert log.get_case("nope") is None

process_intelligence-0.1.0/utils/__init__.py

@@ -0,0 +1 @@
+# utils package

process_intelligence-0.1.0/utils/helpers.py

@@ -0,0 +1,45 @@
+"""Miscellaneous helper utilities."""
+
+import uuid
+import hashlib
+from typing import Any, List
+
+
+def generate_id(prefix: str = "") -> str:
+    """Return a short unique identifier with an optional prefix."""
+    uid = uuid.uuid4().hex[:8]
+    return f"{prefix}-{uid}" if prefix else uid
+
+
+def format_duration(seconds: float) -> str:
+    """Convert a duration in seconds to a human-readable string."""
+    if seconds < 60:
+        return f"{seconds:.1f}s"
+    minutes, secs = divmod(seconds, 60)
+    if minutes < 60:
+        return f"{int(minutes)}m {int(secs)}s"
+    hours, mins = divmod(minutes, 60)
+    return f"{int(hours)}h {int(mins)}m"
+
+
+def flatten(nested: List[Any]) -> List[Any]:
+    """Recursively flatten a nested list."""
+    result: List[Any] = []
+    for item in nested:
+        if isinstance(item, list):
+            result.extend(flatten(item))
+        else:
+            result.append(item)
+    return result
+
+
+def compute_checksum(data: str) -> str:
+    """Return the SHA-256 hex digest of the given string."""
+    return hashlib.sha256(data.encode()).hexdigest()
+
+
+def chunk_list(lst: List[Any], size: int) -> List[List[Any]]:
+    """Split *lst* into consecutive chunks of *size* elements."""
+    if size <= 0:
+        raise ValueError("Chunk size must be a positive integer.")
+    return [lst[i : i + size] for i in range(0, len(lst), size)]

process_intelligence-0.1.0/utils/logger.py

@@ -0,0 +1,29 @@
+"""Lightweight logging wrapper."""
+
+import logging
+import sys
+
+
+def get_logger(name: str, level: str = "INFO") -> logging.Logger:
+    """Return a configured :class:`logging.Logger` instance.
+
+    Parameters
+    ----------
+    name:
+        Logger name, typically ``__name__``.
+    level:
+        Logging level as a string (e.g. ``"DEBUG"``, ``"INFO"``).
+    """
+    logger = logging.getLogger(name)
+    if not logger.handlers:
+        handler = logging.StreamHandler(sys.stdout)
+        formatter = logging.Formatter(
+            fmt="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
+            datefmt="%Y-%m-%dT%H:%M:%S",
+        )
+        handler.setFormatter(formatter)
+        logger.addHandler(handler)
+
+    numeric_level = getattr(logging, level.upper(), logging.INFO)
+    logger.setLevel(numeric_level)
+    return logger