jsp-vis 1.0.0__tar.gz

jsp_vis-1.0.0/LICENSE

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

jsp_vis-1.0.0/MANIFEST.in

@@ -0,0 +1 @@
+# MANIFEST.in

jsp_vis-1.0.0/PKG-INFO

@@ -0,0 +1,169 @@
+Metadata-Version: 2.1
+Name: jsp-vis
+Version: 1.0.0
+Summary: A flexible enviorment for job shop scheduling using the disjunctive graph apporach.
+Author: Alexander Nasuta
+Author-email: Alexander Nasuta <alexander.nasuta@ima.rwth-aachen.de>
+License: MIT License
+        
+        Copyright (c) 2024 Alexander Nasuta
+        
+        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.
+Project-URL: Homepage, https://github.com/Alexander-Nasuta/pypitemplate
+Platform: unix
+Platform: linux
+Platform: osx
+Platform: cygwin
+Platform: win32
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: opencv-python
+Requires-Dist: plotly
+Requires-Dist: matplotlib
+Requires-Dist: numpy
+Requires-Dist: pandas
+Requires-Dist: kaleido
+Provides-Extra: dev
+Requires-Dist: pip-tools; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: tox; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+
+
+
+<div id="top"></div>
+
+<!-- PROJECT LOGO -->
+<br />
+<div align="center">
+   <!--
+  <a href="https://cybernetics-lab.de/">
+    <img src="https://github.com/Alexander-Nasuta/graph-jsp-env/raw/master/resources/readme_images/logo.png" alt="Logo" height="80">
+  </a>
+   -->
+
+  <h1 align="center">
+     Job Shop Scheduling Problem Visualisations
+  </h1>
+
+   <!--
+   <a>
+    <img src="https://github.com/Alexander-Nasuta/graph-jsp-env/raw/master/resources/readme_images/graph_jsp_tikz.png" alt="Logo" height="180">
+  </a>
+-->
+
+</div>
+
+
+- **Github**: https://github.com/Alexander-Nasuta/jsp-vis
+
+- **PyPi**: 
+
+
+# About The Project
+Ths project provides visualisation for the Job Shop Scheduling Problem (JSP).
+This is focused on Gantt charts. The input date for the visualisation is inspired by [plotly's Gantt chart api](https://plotly.com/python/gantt/). 
+`jsp-vis` is a standalone package and in designed to be used in combination with a JSP-reinforcement learning environments that follow the [Gymnasium Environment](https://gymnasium.farama.org/) standard.
+The render function of the environment can be used to render the Gantt chart.
+Typically the render function can implement different modes like `human`, `rgb_array` or `ansi` rendering.
+The `jsp-vis` package offers three different visualisations: console visualisation, rgb_array visualisation and window visualisation.
+The window visualisation is essentially only rendering the rgb_array visualisation in a window using OpenCV.
+The console visualisation might be used for the `asni` mode of a render function, the rgb_array visualisation for the `rgb_array` mode and the window visualisation for the `human` mode.
+
+# Installation
+
+Install the package with pip:
+```
+   pip install todo
+```
+
+# Minimal Working Example: console visualisation
+
+```python
+import pandas
+from jsp_vis.console import gantt_chart_console
+import pandas as pd
+
+df = pd.DataFrame([
+   {'Task': 'Job 0', 'Start': 5, 'Finish': 16, 'Resource': 'Machine 0'},
+   {'Task': 'Job 0', 'Start': 28, 'Finish': 31, 'Resource': 'Machine 1'},
+   {'Task': 'Job 0', 'Start': 31, 'Finish': 34, 'Resource': 'Machine 2'},
+   {'Task': 'Job 0', 'Start': 34, 'Finish': 46, 'Resource': 'Machine 3'},
+   {'Task': 'Job 1', 'Start': 0, 'Finish': 5, 'Resource': 'Machine 0'},
+   {'Task': 'Job 1', 'Start': 5, 'Finish': 21, 'Resource': 'Machine 2'},
+   {'Task': 'Job 1', 'Start': 21, 'Finish': 28, 'Resource': 'Machine 1'},
+   {'Task': 'Job 1', 'Start': 28, 'Finish': 32, 'Resource': 'Machine 3'}
+])
+num_of_machines = 4
+
+gantt_chart_console(df, num_of_machines)
+```
+The code above will render the following Gantt chart in the console:
+
+![](https://github.com/Alexander-Nasuta/graph-jsp-env/raw/master/resources/readme_images/ft06_window_presi.gif)
+
+# Minimal Working Example: console visualisation
+
+```python
+from jsp_vis.cv2_window import render_gantt_in_window
+import pandas as pd
+
+df = pd.DataFrame([
+   {'Task': 'Job 0', 'Start': 5, 'Finish': 16, 'Resource': 'Machine 0'},
+   {'Task': 'Job 0', 'Start': 28, 'Finish': 31, 'Resource': 'Machine 1'},
+   {'Task': 'Job 0', 'Start': 31, 'Finish': 34, 'Resource': 'Machine 2'},
+   {'Task': 'Job 0', 'Start': 34, 'Finish': 46, 'Resource': 'Machine 3'},
+   {'Task': 'Job 1', 'Start': 0, 'Finish': 5, 'Resource': 'Machine 0'},
+   {'Task': 'Job 1', 'Start': 5, 'Finish': 21, 'Resource': 'Machine 2'},
+   {'Task': 'Job 1', 'Start': 21, 'Finish': 28, 'Resource': 'Machine 1'},
+   {'Task': 'Job 1', 'Start': 28, 'Finish': 32, 'Resource': 'Machine 3'}
+])
+num_of_machines = 4
+
+render_gantt_in_window(
+        df=df,
+        n_machines=num_of_machines,
+        wait=2000 # time in ms that the `cv2`-window is open.
+        # wait=None # ''None'' will keep the window open till a keyboard occurs.
+    )
+```
+
+The code above will render the following Gantt chart in the console:
+
+![](https://github.com/Alexander-Nasuta/graph-jsp-env/raw/master/resources/readme_images/ft06_window_presi.gif)
+
+
+# More Examples
+For more examples you can have a look at the test files in the `tests` directory.
+Every visualisation has its own test file and is tested on two different jsp instances defined in the `conftest.py`.
+
+# License
+
+Distributed under the MIT License. See `LICENSE.txt` for more information.
+
+<!-- MARKDOWN LINKS & IMAGES todo: add Github, Linked in etc.-->
+<!-- https://www.markdownguide.org/basic-syntax/#reference-style-links -->
+[screenshot]: resources/readme_images/screenshot.png
+
+

jsp_vis-1.0.0/README.md

@@ -0,0 +1,117 @@
+
+
+<div id="top"></div>
+
+<!-- PROJECT LOGO -->
+<br />
+<div align="center">
+   <!--
+  <a href="https://cybernetics-lab.de/">
+    <img src="https://github.com/Alexander-Nasuta/graph-jsp-env/raw/master/resources/readme_images/logo.png" alt="Logo" height="80">
+  </a>
+   -->
+
+  <h1 align="center">
+     Job Shop Scheduling Problem Visualisations
+  </h1>
+
+   <!--
+   <a>
+    <img src="https://github.com/Alexander-Nasuta/graph-jsp-env/raw/master/resources/readme_images/graph_jsp_tikz.png" alt="Logo" height="180">
+  </a>
+-->
+
+</div>
+
+
+- **Github**: https://github.com/Alexander-Nasuta/jsp-vis
+
+- **PyPi**: 
+
+
+# About The Project
+Ths project provides visualisation for the Job Shop Scheduling Problem (JSP).
+This is focused on Gantt charts. The input date for the visualisation is inspired by [plotly's Gantt chart api](https://plotly.com/python/gantt/). 
+`jsp-vis` is a standalone package and in designed to be used in combination with a JSP-reinforcement learning environments that follow the [Gymnasium Environment](https://gymnasium.farama.org/) standard.
+The render function of the environment can be used to render the Gantt chart.
+Typically the render function can implement different modes like `human`, `rgb_array` or `ansi` rendering.
+The `jsp-vis` package offers three different visualisations: console visualisation, rgb_array visualisation and window visualisation.
+The window visualisation is essentially only rendering the rgb_array visualisation in a window using OpenCV.
+The console visualisation might be used for the `asni` mode of a render function, the rgb_array visualisation for the `rgb_array` mode and the window visualisation for the `human` mode.
+
+# Installation
+
+Install the package with pip:
+```
+   pip install todo
+```
+
+# Minimal Working Example: console visualisation
+
+```python
+import pandas
+from jsp_vis.console import gantt_chart_console
+import pandas as pd
+
+df = pd.DataFrame([
+   {'Task': 'Job 0', 'Start': 5, 'Finish': 16, 'Resource': 'Machine 0'},
+   {'Task': 'Job 0', 'Start': 28, 'Finish': 31, 'Resource': 'Machine 1'},
+   {'Task': 'Job 0', 'Start': 31, 'Finish': 34, 'Resource': 'Machine 2'},
+   {'Task': 'Job 0', 'Start': 34, 'Finish': 46, 'Resource': 'Machine 3'},
+   {'Task': 'Job 1', 'Start': 0, 'Finish': 5, 'Resource': 'Machine 0'},
+   {'Task': 'Job 1', 'Start': 5, 'Finish': 21, 'Resource': 'Machine 2'},
+   {'Task': 'Job 1', 'Start': 21, 'Finish': 28, 'Resource': 'Machine 1'},
+   {'Task': 'Job 1', 'Start': 28, 'Finish': 32, 'Resource': 'Machine 3'}
+])
+num_of_machines = 4
+
+gantt_chart_console(df, num_of_machines)
+```
+The code above will render the following Gantt chart in the console:
+
+![](https://github.com/Alexander-Nasuta/graph-jsp-env/raw/master/resources/readme_images/ft06_window_presi.gif)
+
+# Minimal Working Example: console visualisation
+
+```python
+from jsp_vis.cv2_window import render_gantt_in_window
+import pandas as pd
+
+df = pd.DataFrame([
+   {'Task': 'Job 0', 'Start': 5, 'Finish': 16, 'Resource': 'Machine 0'},
+   {'Task': 'Job 0', 'Start': 28, 'Finish': 31, 'Resource': 'Machine 1'},
+   {'Task': 'Job 0', 'Start': 31, 'Finish': 34, 'Resource': 'Machine 2'},
+   {'Task': 'Job 0', 'Start': 34, 'Finish': 46, 'Resource': 'Machine 3'},
+   {'Task': 'Job 1', 'Start': 0, 'Finish': 5, 'Resource': 'Machine 0'},
+   {'Task': 'Job 1', 'Start': 5, 'Finish': 21, 'Resource': 'Machine 2'},
+   {'Task': 'Job 1', 'Start': 21, 'Finish': 28, 'Resource': 'Machine 1'},
+   {'Task': 'Job 1', 'Start': 28, 'Finish': 32, 'Resource': 'Machine 3'}
+])
+num_of_machines = 4
+
+render_gantt_in_window(
+        df=df,
+        n_machines=num_of_machines,
+        wait=2000 # time in ms that the `cv2`-window is open.
+        # wait=None # ''None'' will keep the window open till a keyboard occurs.
+    )
+```
+
+The code above will render the following Gantt chart in the console:
+
+![](https://github.com/Alexander-Nasuta/graph-jsp-env/raw/master/resources/readme_images/ft06_window_presi.gif)
+
+
+# More Examples
+For more examples you can have a look at the test files in the `tests` directory.
+Every visualisation has its own test file and is tested on two different jsp instances defined in the `conftest.py`.
+
+# License
+
+Distributed under the MIT License. See `LICENSE.txt` for more information.
+
+<!-- MARKDOWN LINKS & IMAGES todo: add Github, Linked in etc.-->
+<!-- https://www.markdownguide.org/basic-syntax/#reference-style-links -->
+[screenshot]: resources/readme_images/screenshot.png
+
+

jsp_vis-1.0.0/pyproject.toml

@@ -0,0 +1,45 @@
+[build-system]
+requires = ["setuptools>=65.5.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "jsp-vis"
+version = "1.0.0"
+description = "A flexible enviorment for job shop scheduling using the disjunctive graph apporach."
+readme = "README.md"
+authors = [{ name = "Alexander Nasuta", email = "alexander.nasuta@ima.rwth-aachen.de" }]
+license = { file = "LICENSE" }
+classifiers = [
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 3",
+]
+keywords = []
+dependencies = [
+    "opencv-python",
+    "plotly",
+    # "networkx>=3",
+    "matplotlib",
+    "numpy",
+    "pandas",
+    "kaleido",
+]
+requires-python = ">=3.9"
+
+[project.optional-dependencies]
+dev = [
+    "pip-tools",
+    "pytest",
+    "pytest-cov",
+    "tox",
+    "twine"
+]
+
+[project.urls]
+Homepage = "https://github.com/Alexander-Nasuta/pypitemplate"
+
+[tool.pytest.ini_options]
+addopts = "--cov=jsp_vis -p no:warnings"
+testpaths = [
+    "tests",
+]

jsp_vis-1.0.0/setup.cfg

@@ -0,0 +1,23 @@
+[metadata]
+name = jsp-vis
+author = Alexander Nasuta
+license = MIT
+license_files = LICENSE
+platforms = unix, linux, osx, cygwin, win32
+classifiers = 
+	Programming Language :: Python :: 3
+	Programming Language :: Python :: 3 :: Only
+	Programming Language :: Python :: 3.11
+
+[options]
+packages = 
+	jsp_vis
+python_requires = >=3.11
+package_dir = 
+	=src
+zip_safe = no
+
+[egg_info]
+tag_build = 
+tag_date = 0
+

jsp_vis-1.0.0/setup.py

@@ -0,0 +1,4 @@
+from setuptools import setup
+
+if __name__ == '__main__':
+    setup()

jsp_vis-1.0.0/src/jsp_vis/console.py

@@ -0,0 +1,209 @@
+import itertools
+import shutil
+
+import matplotlib
+import numpy as np
+import pandas as pd
+
+import logging
+
+log = logging.getLogger(__name__)
+
+CEND = "\33[0m"
+
+
+def rgb_color_sequence(r: int | float, g: int | float, b: int | float,
+                       *, format_type: str = 'foreground') -> str:
+    """
+    generates a color-codes, that change the color of text in console outputs.
+
+    rgb values must be numbers between 0 and 255 or 0.0 and 1.0.
+
+    :param r:               red value.
+    :param g:               green value
+    :param b:               blue value
+
+    :param format_type:     specifies weather the foreground-color or the background-color shall be adjusted.
+                            valid options: 'foreground','background'
+    :return:                a string that contains the color-codes.
+    """
+    # type: ignore # noqa: F401
+    if format_type == 'foreground':
+        f = '\033[38;2;{};{};{}m'.format  # font rgb format
+    elif format_type == 'background':
+        f = '\033[48;2;{};{};{}m'.format  # font background rgb format
+    else:
+        raise ValueError(f"format {format_type} is not defined. Use 'foreground' or 'background'.")
+    rgb = [r, g, b]
+
+    if isinstance(r, int) and isinstance(g, int) and isinstance(b, int):
+        if min(rgb) < 0 and max(rgb) > 255:
+            raise ValueError("rgb values must be numbers between 0 and 255 or 0.0 and 1.0")
+        return f(r, g, b)
+    if isinstance(r, float) and isinstance(g, float) and isinstance(b, float):
+        if min(rgb) < 0 and max(rgb) > 1:
+            raise ValueError("rgb values must be numbers between 0 and 255 or 0.0 and 1.0")
+        return f(*[int(n * 255) for n in [r, g, b]])
+
+
+def wrap_with_color_codes(s: object, /, r: int | float, g: int | float, b: int | float, **kwargs) \
+        -> str:
+    """
+    stringify an object and wrap it with console color codes. It adds the color control sequence in front and one
+    at the end that resolves the color again.
+
+    rgb values must be numbers between 0 and 255 or 0.0 and 1.0.
+
+    :param s: the object to stringify and wrap
+    :param r: red value.
+    :param g: green value.
+    :param b: blue value.
+    :param kwargs: additional argument for the 'DisjunctiveGraphJspVisualizer.rgb_color_sequence'-method.
+    :return:
+    """
+    return f"{rgb_color_sequence(r, g, b, **kwargs)}" \
+           f"{s}" \
+           f"{CEND}"
+
+
+def gantt_chart_console(df: pd.DataFrame, n_machines: int, c_map="rainbow") -> None:
+    """
+    console version of the `gantt_chart_rgb_array`-method. prints a gant chart to the console.
+    the parameters need to follow the plotly specification.
+    see: https://plotly.com/python/gantt/ or `gantt_chart_rgb_array`
+
+    :param df:      dataframe according to `plotly` specification (https://plotly.com/python/gantt/).
+
+    :return:        a `plotly` gantt chart as rgb array.
+
+    color example
+
+        import numpy as np
+
+        c_map = plt.cm.get_cmap("jet")  # select the desired cmap
+        arr = np.linspace(0, 1, 10)  # create a list with numbers from 0 to 1 with n items
+        colors = {resource: c_map(val) for resource, val in enumerate(arr)}
+    """
+    w, h = shutil.get_terminal_size((80, 20))  # enable emulate output in terminal ...
+
+    c_map = matplotlib.colormaps.get_cmap(c_map)  # select the desired cmap
+    arr = np.linspace(0, 1, n_machines)  # create a list with numbers from 0 to 1 with n items
+    machine_colors = {m_id: c_map(val) for m_id, val in enumerate(arr)}
+    colors = {f"Machine {m_id}": (r, g, b) for m_id, (r, g, b, a) in machine_colors.items()}
+
+    if len(df) > 0:
+        machines = sorted(df['Resource'].unique())
+        jobs = df['Task'].unique()
+        jobs.sort()
+    else:
+        jobs, machines = None, None
+
+    len_prefix = 10
+    len_suffix = 15
+
+    x_pixels = w - len_prefix - len_suffix
+    x_max = df['Finish'].max() + 1 if len(df) > 0 else x_pixels
+    if x_pixels < 0:
+        log.warn("terminal window to small")
+        return
+
+    x_axis_tick_small = "╤════"
+    x_axis_tick_big = "╦════"
+    len_tick = len(x_axis_tick_big)
+    num_hole_ticks = x_pixels // len_tick
+    len_last_tick = x_pixels % len_tick
+    x_axis = "".join([
+        f"{'':<{len_prefix - 1}}╚",
+        *[x_axis_tick_big if i % 5 == 0 else x_axis_tick_small for i in range(num_hole_ticks)],
+        "═" * len_last_tick + "╝"
+    ])
+    x_chart_frame_top = "".join([
+        f"{'':<{len_prefix - 1}}╔",
+        "═" * x_pixels,
+        "╗"
+    ])
+
+    x_interval_increment5 = x_max / num_hole_ticks
+    x_interval_increment1 = x_max / x_pixels
+
+    x_axis_label = "".join([
+        f"{'':<{len_prefix}}",
+        *[
+            f"{f'{i * x_interval_increment5:.1f}':<5}" if i % 5 == 0 else f"{'':<5}"
+            for i in range(num_hole_ticks)
+        ]
+    ])
+
+    rows = []
+    if len(df) > 0:
+        for j, m in itertools.zip_longest(jobs, machines):
+            matching_tasks = df.loc[df['Task'] == j].iterrows()
+            chart_str = [i * x_interval_increment1 for i in range(x_pixels)]
+            for _, (_, start, finish, resource) in matching_tasks:
+                chart_str = [
+                    f"{rgb_color_sequence(*colors[resource])}█"
+                    if not isinstance(v, str) and start <= v <= finish else v for v in chart_str
+                ]
+            prefix = f"{f'{j}':<{len_prefix - 1}}║" if j else f"{'':<{len_prefix - 1}}║"
+            colored_block = wrap_with_color_codes("█", *colors[m]) if m else None
+            suffix = f"{f'║ {m}':<{len_suffix - 1}}" + f"{colored_block}" if m else f"{f'║':<{len_suffix}}"
+
+            chart_str = [" " if not isinstance(v, str) else v for v in chart_str]
+            chart_str = "".join(chart_str)
+            rows.append(f"{prefix}{chart_str}{CEND}{suffix}")
+    else:
+        rows = ["".join([f"{f'':<{len_prefix - 1}}║", " " * x_pixels, "║"])]
+
+    gant_str = "\n".join([
+        x_chart_frame_top,
+        *rows,
+        x_axis,
+        x_axis_label
+    ])
+    print(gant_str)
+
+
+def graph_console(df: pd.DataFrame, jsp_instance: np.ndarray, c_map="rainbow"):
+    w, _ = shutil.get_terminal_size((80, 20))
+    _, n_jobs, n_machines = jsp_instance.shape
+
+    len_prefix = 10
+    len_suffix = 15
+
+    machine_order = jsp_instance[0]
+
+    if w < 2 * n_jobs + len_prefix + len_suffix:
+        log.warning("terminal window to small")
+        return
+
+    c_map = matplotlib.colormaps.get_cmap(c_map)  # select the desired cmap
+    arr = np.linspace(0, 1, n_machines)  # create a list with numbers from 0 to 1 with n items
+    machine_colors = {m_id: c_map(val) for m_id, val in enumerate(arr)}
+    colors = {f"Machine {m_id}": (r, g, b) for m_id, (r, g, b, a) in machine_colors.items()}
+
+    machine_strings = [
+        f"{m :>{len_suffix - 5}} {wrap_with_color_codes('█', r, g, b)}"
+        for m, (r, g, b) in colors.items()
+    ]
+
+    def task_is_in_df(job: int, machine: int):
+        return any((df['Task'] == f"Job {job}") & (df['Resource'] == f"Machine {machine}"))
+        pass
+
+    for j, m_str in itertools.zip_longest(range(n_jobs), machine_strings):
+        row = f"Job {j}" if j is not None else ""
+        row = f"{row:<{len_prefix}}"
+        for task_in_job in range(n_machines):
+
+            if j is not None:
+                machine_of_task = machine_order[j][task_in_job]
+                node_str = "●" if task_is_in_df(job=j, machine=machine_of_task) else "◯"
+                node_str = wrap_with_color_codes(node_str, *colors[f"Machine {machine_of_task}"])
+                if task_in_job < n_machines - 1:
+                    node_str += "-"
+            else:
+                node_str = " "
+                if task_in_job < n_machines - 1:
+                    node_str += " "
+            row += node_str
+        print("".join([row, " " * 4, m_str if m_str is not None else ""]))

jsp_vis-1.0.0/src/jsp_vis/cv2_window.py

@@ -0,0 +1,69 @@
+import cv2
+import signal
+
+import pandas as pd
+import numpy.typing as npt
+
+from jsp_vis.rgb_array import gantt_chart_rgb_array
+
+
+def handler_stop_signals(*_) -> None:
+    """
+    closes all `cv2`-windows when the process is killed
+    """
+    cv2.destroyAllWindows()
+
+
+signal.signal(signal.SIGINT, handler_stop_signals)
+signal.signal(signal.SIGTERM, handler_stop_signals)
+
+
+def render_rgb_array(vis: npt.NDArray, *, window_title: str = "Job Shop Scheduling", wait: int = 1) -> None:
+    """
+    renders a rgb-array in an `cv2` window.
+    the window will remain open for `:param wait:` ms or till the user presses any key.
+
+    :param vis:             the rgb-array to render.
+    :param window_title:    the title of the `cv2`-window
+    :param wait:            time in ms that the `cv2`-window is open.
+                            if `None`, then the window will remain open till a keyboard occurs.
+
+    :return:
+    """
+    vis = cv2.cvtColor(vis, cv2.COLOR_RGB2BGR)
+    cv2.imshow(window_title, vis)
+    # https://stackoverflow.com/questions/64061721/opencv-to-close-the-window-on-a-specific-key
+    k = cv2.waitKey(wait) & 0xFF
+    if k == 27:  # wait for ESC key to exit
+        cv2.destroyAllWindows()
+
+
+def render_gantt_in_window(df: pd.DataFrame, *, n_machines: int, gantt_chart_rgb_array_kwargs: dict | None =None,
+                           **render_kwargs: dict) -> None:
+    """
+    wrapper for the `gantt_chart_rgb_array`- and `render_rgb_array`-methods
+
+    :param df:              parameter for `gantt_chart_rgb_array`
+    :param n_machines:          parameter for `gantt_chart_rgb_array`
+    :param render_kwargs:   additional parameters for `render_rgb_array`
+
+    :return:                None
+    """
+    if gantt_chart_rgb_array_kwargs is None:
+        gantt_chart_rgb_array_kwargs = {}
+    vis = gantt_chart_rgb_array(df=df, n_machines=n_machines, **gantt_chart_rgb_array_kwargs)
+    render_rgb_array(vis, **render_kwargs)
+
+
+if __name__ == '__main__':
+    df = [
+        {'Task': 'Job 0', 'Start': 5, 'Finish': 16, 'Resource': 'Machine 0'},
+        {'Task': 'Job 0', 'Start': 28, 'Finish': 31, 'Resource': 'Machine 1'},
+        {'Task': 'Job 0', 'Start': 31, 'Finish': 34, 'Resource': 'Machine 2'},
+        {'Task': 'Job 0', 'Start': 34, 'Finish': 46, 'Resource': 'Machine 3'},
+        {'Task': 'Job 1', 'Start': 0, 'Finish': 5, 'Resource': 'Machine 0'},
+        {'Task': 'Job 1', 'Start': 5, 'Finish': 21, 'Resource': 'Machine 2'},
+        {'Task': 'Job 1', 'Start': 21, 'Finish': 28, 'Resource': 'Machine 1'},
+        {'Task': 'Job 1', 'Start': 28, 'Finish': 32, 'Resource': 'Machine 3'}
+    ]
+    render_gantt_in_window(pd.DataFrame(df), n_machines=4, wait=None)

jsp_vis-1.0.0/src/jsp_vis/rgb_array.py

@@ -0,0 +1,49 @@
+import cv2
+
+import pandas as pd
+import numpy as np
+
+import matplotlib.pyplot as plt
+import matplotlib as mpl
+import plotly.figure_factory as ff
+
+
+def gantt_chart_rgb_array(df: pd.DataFrame, n_machines: int, *,
+                          c_map="rainbow",
+                          dpi=80,
+                          width=7.5,
+                          height=5,
+                          show_colorbar=True,
+                          index_col='Resource',
+                          group_tasks=True,
+                          xaxis_type='linear') -> np.ndarray:
+    c_map = mpl.colormaps.get_cmap(c_map)  # select the desired cmap
+    arr = np.linspace(0, 1, n_machines)  # create a list with numbers from 0 to 1 with n items
+    machine_colors = {m_id: c_map(val) for m_id, val in enumerate(arr)}
+    colors = {f"Machine {m_id}": (r, g, b) for m_id, (r, g, b, a) in machine_colors.items()}
+
+    plt.figure(dpi=dpi)
+    plt.axis("off")
+    plt.tight_layout()
+
+    fig = mpl.pyplot.gcf()
+    fig.set_size_inches(width, height)
+
+    # Gantt chart
+    width, height = fig.canvas.get_width_height()
+    if not len(df):
+        df = pd.DataFrame([{"Task": "Job 0", "Start": 0, "Finish": 0, "Resource": "Machine 0"}])
+    fig = ff.create_gantt(df=df, show_colorbar=show_colorbar, index_col=index_col, group_tasks=group_tasks,
+                          colors=colors)
+    fig.update_layout(xaxis_type=xaxis_type)
+
+    img_str = fig.to_image(format="jpg", width=width, height=height)
+
+    nparr = np.frombuffer(img_str, np.uint8)
+    img = cv2.imdecode(nparr, cv2.IMREAD_COLOR)  # cv2.IMREAD_COLOR in OpenCV 3.1
+    img = cv2.cvtColor(img, cv2.COLOR_RGB2BGR)
+
+    # clear current frame
+    plt.clf()
+    plt.close('all')
+    return img

jsp_vis-1.0.0/src/jsp_vis.egg-info/PKG-INFO

@@ -0,0 +1,169 @@
+Metadata-Version: 2.1
+Name: jsp-vis
+Version: 1.0.0
+Summary: A flexible enviorment for job shop scheduling using the disjunctive graph apporach.
+Author: Alexander Nasuta
+Author-email: Alexander Nasuta <alexander.nasuta@ima.rwth-aachen.de>
+License: MIT License
+        
+        Copyright (c) 2024 Alexander Nasuta
+        
+        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.
+Project-URL: Homepage, https://github.com/Alexander-Nasuta/pypitemplate
+Platform: unix
+Platform: linux
+Platform: osx
+Platform: cygwin
+Platform: win32
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: opencv-python
+Requires-Dist: plotly
+Requires-Dist: matplotlib
+Requires-Dist: numpy
+Requires-Dist: pandas
+Requires-Dist: kaleido
+Provides-Extra: dev
+Requires-Dist: pip-tools; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: tox; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+
+
+
+<div id="top"></div>
+
+<!-- PROJECT LOGO -->
+<br />
+<div align="center">
+   <!--
+  <a href="https://cybernetics-lab.de/">
+    <img src="https://github.com/Alexander-Nasuta/graph-jsp-env/raw/master/resources/readme_images/logo.png" alt="Logo" height="80">
+  </a>
+   -->
+
+  <h1 align="center">
+     Job Shop Scheduling Problem Visualisations
+  </h1>
+
+   <!--
+   <a>
+    <img src="https://github.com/Alexander-Nasuta/graph-jsp-env/raw/master/resources/readme_images/graph_jsp_tikz.png" alt="Logo" height="180">
+  </a>
+-->
+
+</div>
+
+
+- **Github**: https://github.com/Alexander-Nasuta/jsp-vis
+
+- **PyPi**: 
+
+
+# About The Project
+Ths project provides visualisation for the Job Shop Scheduling Problem (JSP).
+This is focused on Gantt charts. The input date for the visualisation is inspired by [plotly's Gantt chart api](https://plotly.com/python/gantt/). 
+`jsp-vis` is a standalone package and in designed to be used in combination with a JSP-reinforcement learning environments that follow the [Gymnasium Environment](https://gymnasium.farama.org/) standard.
+The render function of the environment can be used to render the Gantt chart.
+Typically the render function can implement different modes like `human`, `rgb_array` or `ansi` rendering.
+The `jsp-vis` package offers three different visualisations: console visualisation, rgb_array visualisation and window visualisation.
+The window visualisation is essentially only rendering the rgb_array visualisation in a window using OpenCV.
+The console visualisation might be used for the `asni` mode of a render function, the rgb_array visualisation for the `rgb_array` mode and the window visualisation for the `human` mode.
+
+# Installation
+
+Install the package with pip:
+```
+   pip install todo
+```
+
+# Minimal Working Example: console visualisation
+
+```python
+import pandas
+from jsp_vis.console import gantt_chart_console
+import pandas as pd
+
+df = pd.DataFrame([
+   {'Task': 'Job 0', 'Start': 5, 'Finish': 16, 'Resource': 'Machine 0'},
+   {'Task': 'Job 0', 'Start': 28, 'Finish': 31, 'Resource': 'Machine 1'},
+   {'Task': 'Job 0', 'Start': 31, 'Finish': 34, 'Resource': 'Machine 2'},
+   {'Task': 'Job 0', 'Start': 34, 'Finish': 46, 'Resource': 'Machine 3'},
+   {'Task': 'Job 1', 'Start': 0, 'Finish': 5, 'Resource': 'Machine 0'},
+   {'Task': 'Job 1', 'Start': 5, 'Finish': 21, 'Resource': 'Machine 2'},
+   {'Task': 'Job 1', 'Start': 21, 'Finish': 28, 'Resource': 'Machine 1'},
+   {'Task': 'Job 1', 'Start': 28, 'Finish': 32, 'Resource': 'Machine 3'}
+])
+num_of_machines = 4
+
+gantt_chart_console(df, num_of_machines)
+```
+The code above will render the following Gantt chart in the console:
+
+![](https://github.com/Alexander-Nasuta/graph-jsp-env/raw/master/resources/readme_images/ft06_window_presi.gif)
+
+# Minimal Working Example: console visualisation
+
+```python
+from jsp_vis.cv2_window import render_gantt_in_window
+import pandas as pd
+
+df = pd.DataFrame([
+   {'Task': 'Job 0', 'Start': 5, 'Finish': 16, 'Resource': 'Machine 0'},
+   {'Task': 'Job 0', 'Start': 28, 'Finish': 31, 'Resource': 'Machine 1'},
+   {'Task': 'Job 0', 'Start': 31, 'Finish': 34, 'Resource': 'Machine 2'},
+   {'Task': 'Job 0', 'Start': 34, 'Finish': 46, 'Resource': 'Machine 3'},
+   {'Task': 'Job 1', 'Start': 0, 'Finish': 5, 'Resource': 'Machine 0'},
+   {'Task': 'Job 1', 'Start': 5, 'Finish': 21, 'Resource': 'Machine 2'},
+   {'Task': 'Job 1', 'Start': 21, 'Finish': 28, 'Resource': 'Machine 1'},
+   {'Task': 'Job 1', 'Start': 28, 'Finish': 32, 'Resource': 'Machine 3'}
+])
+num_of_machines = 4
+
+render_gantt_in_window(
+        df=df,
+        n_machines=num_of_machines,
+        wait=2000 # time in ms that the `cv2`-window is open.
+        # wait=None # ''None'' will keep the window open till a keyboard occurs.
+    )
+```
+
+The code above will render the following Gantt chart in the console:
+
+![](https://github.com/Alexander-Nasuta/graph-jsp-env/raw/master/resources/readme_images/ft06_window_presi.gif)
+
+
+# More Examples
+For more examples you can have a look at the test files in the `tests` directory.
+Every visualisation has its own test file and is tested on two different jsp instances defined in the `conftest.py`.
+
+# License
+
+Distributed under the MIT License. See `LICENSE.txt` for more information.
+
+<!-- MARKDOWN LINKS & IMAGES todo: add Github, Linked in etc.-->
+<!-- https://www.markdownguide.org/basic-syntax/#reference-style-links -->
+[screenshot]: resources/readme_images/screenshot.png
+
+

jsp_vis-1.0.0/src/jsp_vis.egg-info/SOURCES.txt

@@ -0,0 +1,19 @@
+LICENSE
+MANIFEST.in
+README.md
+pyproject.toml
+setup.cfg
+setup.py
+src/jsp_vis/__init__.py
+src/jsp_vis/console.py
+src/jsp_vis/cv2_window.py
+src/jsp_vis/rgb_array.py
+src/jsp_vis.egg-info/PKG-INFO
+src/jsp_vis.egg-info/SOURCES.txt
+src/jsp_vis.egg-info/dependency_links.txt
+src/jsp_vis.egg-info/not-zip-safe
+src/jsp_vis.egg-info/requires.txt
+src/jsp_vis.egg-info/top_level.txt
+tests/test_render_console.py
+tests/test_render_cv2_window.py
+tests/test_render_rgb_array.py

jsp_vis-1.0.0/src/jsp_vis.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

jsp_vis-1.0.0/src/jsp_vis.egg-info/not-zip-safe

@@ -0,0 +1 @@
+

jsp_vis-1.0.0/src/jsp_vis.egg-info/requires.txt

@@ -0,0 +1,13 @@
+opencv-python
+plotly
+matplotlib
+numpy
+pandas
+kaleido
+
+[dev]
+pip-tools
+pytest
+pytest-cov
+tox
+twine

jsp_vis-1.0.0/src/jsp_vis.egg-info/top_level.txt

@@ -0,0 +1 @@
+jsp_vis

jsp_vis-1.0.0/tests/test_render_console.py

@@ -0,0 +1,25 @@
+import pandas as pd
+
+from jsp_vis.console import gantt_chart_console, graph_console
+
+
+def test_gantt_console(custom_jsp_instance_df, custom_jsp_n_machines):
+    gantt_chart_console(pd.DataFrame(custom_jsp_instance_df), custom_jsp_n_machines)
+
+
+def test_gantt_console_ft06(ft06_df, ft06_n_machines):
+    gantt_chart_console(pd.DataFrame(ft06_df), ft06_n_machines)
+
+
+def test_graph_console(custom_jsp_instance, custom_jsp_instance_df):
+    graph_console(
+        df=pd.DataFrame(custom_jsp_instance_df),
+        jsp_instance=custom_jsp_instance,
+    )
+
+
+def test_graph_console_ft06(ft06, ft06_df):
+    graph_console(
+        df=pd.DataFrame(ft06_df),
+        jsp_instance=ft06,
+    )

jsp_vis-1.0.0/tests/test_render_cv2_window.py

@@ -0,0 +1,30 @@
+import sys
+
+import pytest
+
+
+@pytest.mark.skipif(sys.platform == 'linux',
+                    reason="the Github Actions runner is configured to run on Linux. "
+                           "The runner does not have a UI, so the test will fail. ")
+def test_render_cv2_window(custom_jsp_instance_df, custom_jsp_n_machines):
+    from jsp_vis.cv2_window import render_gantt_in_window
+
+    render_gantt_in_window(
+        df=custom_jsp_instance_df,
+        n_machines=custom_jsp_n_machines,
+        wait=1 # time in ms that the `cv2`-window is open.
+        # wait=None # ''None'' will keep the window open till a keyboard occurs.
+    )
+
+@pytest.mark.skipif(sys.platform == 'linux',
+                    reason="the Github Actions runner is configured to run on Linux. "
+                           "The runner does not have a UI, so the test will fail. ")
+def test_render_cv2_window(ft06_df, ft06_n_machines):
+    from jsp_vis.cv2_window import render_gantt_in_window
+
+    render_gantt_in_window(
+        df=ft06_df,
+        n_machines=ft06_n_machines,
+        wait=1 # time in ms that the `cv2`-window is open.
+        # wait=None # ''None'' will keep the window open till a keyboard occurs.
+    )

jsp_vis-1.0.0/tests/test_render_rgb_array.py

@@ -0,0 +1,17 @@
+import numpy as np
+
+
+def test_rgb_array_custom_jsp_instance(custom_jsp_instance_df, custom_jsp_n_machines):
+    from jsp_vis.rgb_array import gantt_chart_rgb_array
+
+    vis = gantt_chart_rgb_array(custom_jsp_instance_df, custom_jsp_n_machines)
+    assert type(vis) == type(np.array([]))
+    assert vis.shape == (400, 600, 3)
+
+
+def test_rgb_array_ft06(ft06_df, ft06_n_machines):
+    from jsp_vis.rgb_array import gantt_chart_rgb_array
+
+    vis = gantt_chart_rgb_array(ft06_df, ft06_n_machines)
+    assert type(vis) == type(np.array([]))
+    assert vis.shape == (400, 600, 3)