junban 1.0.0__tar.gz

junban-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 biocentral
+
+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.

junban-1.0.0/PKG-INFO

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: junban
+Version: 1.0.0
+Summary: Junban – Simple Sequential Python Workflows
+Requires-Python: >=3.11
+License-File: LICENSE
+Dynamic: license-file

junban-1.0.0/README.md

@@ -0,0 +1,81 @@
+# Junban (順番) – Simple Sequential Python Workflows
+
+Junban (english: order) is a lightweight library for defining and executing sequential (scientific) workflows in Python.
+
+## Installation
+
+Junban is available via pypi:
+```python
+
+```
+
+## Quick Example
+
+Here is a simple example showing how to define a context and two steps. It showcases how context is passed between steps
+and how entry/exit assumptions (verification) are handled.
+
+```python
+from dataclasses import dataclass
+from junban.pipeline import Pipeline
+from junban.pipeline_step import PipelineStep
+from junban.pipeline_context import PipelineContext
+
+
+# 1. Define your context by inheriting from PipelineContext
+@dataclass
+class MyContext(PipelineContext):
+    value: int = 0
+    is_processed: bool = False
+
+
+# 2. Create pipeline steps by inheriting from PipelineStep
+class IncrementStep(PipelineStep[MyContext]):
+    def _check_entry_assumptions(self, context: MyContext) -> bool:
+        # Verification before step execution
+        return context.value == 0
+
+    def _execute(self, context: MyContext) -> MyContext:
+        # Core logic of the step
+        context.value += 1
+        return context
+
+    def _check_exit_assumptions(self, context: MyContext) -> bool:
+        # Verification after step execution
+        return context.value == 1
+
+    def get_start_message(self) -> str:
+        return "Incrementing value..."
+
+    def get_end_message(self) -> str:
+        return "Value incremented."
+
+
+class ProcessStep(PipelineStep[MyContext]):
+    def _check_entry_assumptions(self, context: MyContext) -> bool:
+        return context.value > 0
+
+    def _execute(self, context: MyContext) -> MyContext:
+        context.is_processed = True
+        return context
+
+    def _check_exit_assumptions(self, context: MyContext) -> bool:
+        return context.is_processed is True
+
+    def get_start_message(self) -> str:
+        return "Processing..."
+
+    def get_end_message(self) -> str:
+        return "Processed."
+
+
+# 3. Initialize and execute the pipeline
+if __name__ == "__main__":
+    context = MyContext()
+    pipeline = Pipeline(
+        steps=[IncrementStep(), ProcessStep()],
+        name="ExamplePipeline"
+    )
+
+    final_context = pipeline.execute(context)
+    print(f"Final value: {final_context.value}, Processed: {final_context.is_processed}")
+```

junban-1.0.0/junban/__init__.py

@@ -0,0 +1,5 @@
+from .pipeline import Pipeline
+from .pipeline_step import PipelineStep
+from .pipeline_context import PipelineContext
+
+__all__ = ["PipelineStep", "PipelineContext", "Pipeline"]

junban-1.0.0/junban/pipeline.py

@@ -0,0 +1,53 @@
+import logging
+
+from typing import List, Generic, Optional
+
+from .pipeline_context import C
+from .pipeline_step import PipelineStep
+
+
+class Pipeline(Generic[C]):
+    def __init__(self, steps: List[PipelineStep[C]], name: Optional[str] = "PIPELINE",
+                 logger: Optional[logging.Logger] = None):
+        """
+        Main junban pipeline class.
+
+        :param steps: Pipeline steps to be executed.
+        :param name: Name of the pipeline, defaults to "PIPELINE".
+        :param logger: Optional logger to log pipeline steps, defaults to None.
+        If no logger is provided, logs will be printed to stdout.
+        """
+        self.steps: List[PipelineStep[C]] = steps
+        self.name = name
+        self._log_info = lambda msg: self._log_info_func(msg, logger)
+        self._log_error = lambda msg: self._log_error_func(msg, logger)
+
+    @staticmethod
+    def _log_info_func(message: str, logger: logging.Logger = None):
+        if logger is None:
+            print(message)
+        else:
+            logger.info(message)
+
+    @staticmethod
+    def _log_error_func(message: str, logger: logging.Logger = None):
+        if logger is None:
+            print(message)
+        else:
+            logger.error(message)
+
+    def execute(self, context: C) -> C:
+        """ Run the pipeline steps with the given initial context."""
+        current_context = context
+        for step in self.steps:
+            try:
+                self._log_info(f"[{self.name}] {step.get_start_message()}")
+                current_context = step.run(current_context)
+                self._log_info(f"[{self.name}] {step.get_end_message()}")
+            except AssertionError as e:
+                self._log_error(f"[{self.name}] Assertion error in step {step.__class__.__name__}: {str(e)}")
+                raise
+            except Exception as e:
+                self._log_error(f"[{self.name}] Error in step {step.__class__.__name__}: {str(e)}")
+                raise
+        return current_context

junban-1.0.0/junban/pipeline_context.py

@@ -0,0 +1,7 @@
+from typing import TypeVar
+
+class PipelineContext:
+    """ Large struct to hold pipeline context during execution """
+    pass
+
+C = TypeVar("C", bound=PipelineContext)

junban-1.0.0/junban/pipeline_step.py

@@ -0,0 +1,44 @@
+from typing import Generic
+from abc import ABC, abstractmethod
+
+from .pipeline_context import C
+
+
+class PipelineStep(ABC, Generic[C]):
+
+    @abstractmethod
+    def _check_entry_assumptions(self, context: C) -> bool:
+        """ You can use this method to check if the pipeline step can be executed.
+        Depending on your use case, you can use assert statements, raise exceptions, or return a boolean.
+        """
+        return True
+
+    @abstractmethod
+    def _check_exit_assumptions(self, context: C) -> bool:
+        """ You can use this method to check if the pipeline step executed successfully.
+        Depending on your use case, you can use assert statements, raise exceptions, or return a boolean.
+        """
+        return True
+
+    @abstractmethod
+    def get_start_message(self) -> str:
+        raise NotImplementedError
+
+    @abstractmethod
+    def get_end_message(self) -> str:
+        raise NotImplementedError
+
+    @abstractmethod
+    def _execute(self, context: C) -> C:
+        raise NotImplementedError
+
+    def run(self, context: C) -> C:
+        if not self._check_entry_assumptions(context):
+            assert False, "Entry assumptions not met"
+
+        context = self._execute(context)
+
+        if not self._check_exit_assumptions(context):
+            assert False, "Exit assumptions not met"
+
+        return context

junban-1.0.0/junban.egg-info/PKG-INFO

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: junban
+Version: 1.0.0
+Summary: Junban – Simple Sequential Python Workflows
+Requires-Python: >=3.11
+License-File: LICENSE
+Dynamic: license-file

junban-1.0.0/junban.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+LICENSE
+README.md
+pyproject.toml
+junban/__init__.py
+junban/pipeline.py
+junban/pipeline_context.py
+junban/pipeline_step.py
+junban.egg-info/PKG-INFO
+junban.egg-info/SOURCES.txt
+junban.egg-info/dependency_links.txt
+junban.egg-info/top_level.txt

junban-1.0.0/junban.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

junban-1.0.0/junban.egg-info/top_level.txt

@@ -0,0 +1 @@
+junban

junban-1.0.0/pyproject.toml

@@ -0,0 +1,6 @@
+[project]
+name = "junban"
+version = "1.0.0"
+description = "Junban – Simple Sequential Python Workflows"
+requires-python = ">=3.11"
+dependencies = []

junban-1.0.0/setup.cfg

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