salabim 25.0.12__tar.gz → 25.0.14__tar.gz

{salabim-25.0.12 → salabim-25.0.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: salabim
-Version: 25.0.12
+Version: 25.0.14
 Summary: salabim - discrete event simulation in Python
 Author-email: Ruud van der Ham <rt.van.der.ham@gmail.com>
 Project-URL: Homepage, https://salabim.org

{salabim-25.0.12 → salabim-25.0.14}/pyproject.toml

@@ -10,7 +10,7 @@ authors = [
     { name = "Ruud van der Ham", email = "rt.van.der.ham@gmail.com" },
 ]
 description = "salabim - discrete event simulation in Python"
-version = "25.0.12"
+version = "25.0.14"
 readme = "README.md"
 requires-python = ">=3.7"
 dependencies = []

{salabim-25.0.12 → salabim-25.0.14}/salabim/salabim.py

@@ -1,13 +1,13 @@
-#               _         _      _               ____   ____       ___      _  ____
-#   ___   __ _ | |  __ _ | |__  (_) _ __ ___    |___ \ | ___|     / _ \    / ||___ \
-#  / __| / _` || | / _` || '_ \ | || '_ ` _ \     __) ||___ \    | | | |   | |  __) |
-#  \__ \| (_| || || (_| || |_) || || | | | | |   / __/  ___) | _ | |_| | _ | | / __/
-#  |___/ \__,_||_| \__,_||_.__/ |_||_| |_| |_|  |_____||____/ (_) \___/ (_)|_||_____|
+#               _         _      _               ____   ____       ___      _  _  _
+#   ___   __ _ | |  __ _ | |__  (_) _ __ ___    |___ \ | ___|     / _ \    / || || |
+#  / __| / _` || | / _` || '_ \ | || '_ ` _ \     __) ||___ \    | | | |   | || || |_
+#  \__ \| (_| || || (_| || |_) || || | | | | |   / __/  ___) | _ | |_| | _ | ||__   _|
+#  |___/ \__,_||_| \__,_||_.__/ |_||_| |_| |_|  |_____||____/ (_) \___/ (_)|_|   |_|
 #                    discrete event simulation
 #
 #  see www.salabim.org for more information, the documentation and license information
 
-__version__ = "25.0.12"
+__version__ = "25.0.14"
 import heapq
 import random
 import time
@@ -54,7 +54,7 @@ Windows = sys.platform.startswith("win")
 MacOS = platform.system == "Darwin"
 PyPy = platform.python_implementation() == "PyPy"
 Chromebook = "penguin" in platform.uname()
-Xlwings = "xlwings" in sys.modules
+pyodide = "pyodide" in sys.modules
 
 _color_name_to_ANSI = dict(
     dark_black="\033[0;30m",
@@ -122,7 +122,7 @@ if Pythonista:
 inf = float("inf")
 nan = float("nan")
 
-if Pythonista or Xlwings:
+if Pythonista or pyodide:
     _yieldless = False
 else:
     _yieldless = True
@@ -163,8 +163,8 @@ def yieldless(value: bool = None) -> bool:
         if value:
             if Pythonista:
                 raise ValueError("yiedless mode is not allowed under Pythonista")
-            if Xlwings:
-                raise ValueError("yiedless mode is not allowed under xlwings lite")
+            if pyodide:
+                raise ValueError("yiedless mode is not allowed under pyodide")
         _yieldless = value
     return _yieldless
 
@@ -7680,7 +7680,6 @@ Maybe this a non yieldless model. In that case:
 - run salabim_unyield.py"""
                     )
                 self.env._any_yield = True
-                self._process = p(**kwargs)
                 self._process_isgenerator = True
             else:
                 if not self.env._yieldless and not self.env._any_yield:
@@ -7699,7 +7698,7 @@ by adding:
 
             extra = "process=" + process_name
             if self.env._yieldless:
-                self._glet = greenlet.greenlet(self._process, parent=self.env._glet)
+                self._glet = greenlet.greenlet(lambda: self._process(**kwargs), parent=self.env._glet)  # ***
 
         if self.status.value != current:
             self._remove()
@@ -10605,11 +10604,11 @@ class Environment:
         self._zoom_factor = 1.1
 
         self.last_s0 = ""
-        if Xlwings:
+        if pyodide:
             if blind_animation is None:
                 blind_animation = True
             if not blind_animation:
-                raise ValueError("blind_animation may not be False under xlwings lite")
+                raise ValueError("blind_animation may not be False under pyodide")
         else:
             if blind_animation is None:
                 blind_animation = False
@@ -12059,7 +12058,7 @@ class Environment:
             an_objects = sorted(self.an_objects, key=lambda obj: (-obj.layer(self._t), obj.sequence))
             image = Image.new("RGBA", (self._width, self._height), self.colorspec_to_tuple("bg"))
             for ao in an_objects:
-                ao.make_pil_image(self.t())
+                ao.make_pil_image(self._t)
                 if ao._image_visible and (include_topleft or not ao.getattr("in_topleft", False)):
                     image.paste(ao._image, (int(ao._image_x), int(self._height - ao._image_y - ao._image.size[1])), ao._image.convert("RGBA"))
         return image.convert(mode)
@@ -13613,7 +13612,9 @@ class Environment:
         else:
             raise ValueError("extension " + extension + "  not supported")
         filename_path.parent.mkdir(parents=True, exist_ok=True)
+        self._t = self._now
         self._capture_image(mode, video_mode).save(str(filename))
+        self._t = self.t()
 
     def modelname_width(self):
         if Environment.cached_modelname_width[0] != self._modelname:
@@ -14169,6 +14170,8 @@ class Environment:
         if not screen_coordinates:
             fontsize = fontsize * self._scale
         f, heightA = getfont(font, fontsize)
+        if f is None:
+            return 0
         if text == "":  # necessary because of bug in PIL >= 4.2.1
             thiswidth, thisheight = (0, 0)
         else:
@@ -14182,6 +14185,8 @@ class Environment:
         if not screen_coordinates:
             fontsize = fontsize * self._scale
         f, heightA = getfont(font, fontsize)
+        if f is None:
+            return 0
         thiswidth, thisheight = f.getbbox("Ap")[2:]
         if screen_coordinates:
             return thisheight
@@ -15847,76 +15852,82 @@ class Animate2dBase(DynamicClass):
                     if self._image_ident != self._image_ident_prev:
                         font, heightA = getfont(fontname, fontsize)
 
-                        lines = []
-                        for item in deep_flatten(text):
-                            for line in item.splitlines():
-                                lines.append(line.rstrip())
+                        if font is None:
+                            self.imwidth, self.imheight = 0, 0
+                            self.heightA = 0
+                            self._image = g.dummy_image
 
-                        if max_lines <= 0:  # 0 is all
-                            lines = lines[max_lines:]
                         else:
-                            lines = lines[:max_lines]
+                            lines = []
+                            for item in deep_flatten(text):
+                                for line in item.splitlines():
+                                    lines.append(line.rstrip())
 
-                        widths = [(font.getbbox(line)[2] if line else 0) for line in lines]
-                        if widths:
-                            totwidth = max(widths)
-                        else:
-                            totwidth = 0
-
-                        number_of_lines = len(lines)
-                        lineheight = font.getbbox("Ap")[3]
-                        totheight = number_of_lines * lineheight
-                        im = Image.new("RGBA", (int(totwidth + 0.1 * fontsize), int(totheight)), (0, 0, 0, 0))
-                        imwidth, imheight = im.size
-                        draw = ImageDraw.Draw(im)
-                        ypos = 0
-                        now_color = textcolor
-                        for line, width in zip(lines, widths):
-                            if line:
-                                if "\033[" in line:  # ANSI
-                                    xpos = 0.1 * fontsize
-                                    while line:
-                                        for ansi, rgb in _ANSI_to_rgb.items():
-                                            if line.startswith(ansi):
-                                                if rgb:
-                                                    now_color = rgb
-                                                else:
-                                                    now_color = textcolor
-                                                line = line[len(ansi) :]
-                                                break
-                                        else:
-                                            c = line[0]
-                                            draw.text(xy=(xpos, ypos), text=c, font=font, fill=now_color)
-                                            charwidth = font.getbbox(c)[2]
-                                            xpos += charwidth
-                                            line = line[1:]
+                            if max_lines <= 0:  # 0 is all
+                                lines = lines[max_lines:]
+                            else:
+                                lines = lines[:max_lines]
 
-                                else:
-                                    draw.text(xy=(0.1 * fontsize, ypos), text=line, font=font, fill=now_color)
-
-                            ypos += lineheight
-                        # # this code is to correct a bug in the rendering of text,
-                        # # leaving a kind of shadow around the text
-                        # del draw
-                        # if textcolor[:3] != (0, 0, 0):  # black is ok
-                        #     if False and has_numpy():
-                        #         arr = numpy.asarray(im).copy()
-                        #         arr[:, :, 0] = textcolor[0]
-                        #         arr[:, :, 1] = textcolor[1]
-                        #         arr[:, :, 2] = textcolor[2]
-                        #         im = Image.fromarray(numpy.uint8(arr))
-                        #     else:
-                        #         pix = im.load()
-                        #         for y in range(imheight):
-                        #             for x in range(imwidth):
-                        #                 pix[x, y] = (textcolor[0], textcolor[1], textcolor[2], pix[x, y][3])
-
-                        # # end of code to correct bug
-
-                        self.imwidth, self.imheight = im.size
-                        self.heightA = heightA
-
-                        self._image = im.rotate(angle, expand=1)
+                            widths = [(font.getbbox(line)[2] if line else 0) for line in lines]
+                            if widths:
+                                totwidth = max(widths)
+                            else:
+                                totwidth = 0
+
+                            number_of_lines = len(lines)
+                            lineheight = font.getbbox("Ap")[3]
+                            totheight = number_of_lines * lineheight
+                            im = Image.new("RGBA", (int(totwidth + 0.1 * fontsize), int(totheight)), (0, 0, 0, 0))
+                            imwidth, imheight = im.size
+                            draw = ImageDraw.Draw(im)
+                            ypos = 0
+                            now_color = textcolor
+                            for line, width in zip(lines, widths):
+                                if line:
+                                    if "\033[" in line:  # ANSI
+                                        xpos = 0.1 * fontsize
+                                        while line:
+                                            for ansi, rgb in _ANSI_to_rgb.items():
+                                                if line.startswith(ansi):
+                                                    if rgb:
+                                                        now_color = rgb
+                                                    else:
+                                                        now_color = textcolor
+                                                    line = line[len(ansi) :]
+                                                    break
+                                            else:
+                                                c = line[0]
+                                                draw.text(xy=(xpos, ypos), text=c, font=font, fill=now_color)
+                                                charwidth = font.getbbox(c)[2]
+                                                xpos += charwidth
+                                                line = line[1:]
+
+                                    else:
+                                        draw.text(xy=(0.1 * fontsize, ypos), text=line, font=font, fill=now_color)
+
+                                ypos += lineheight
+                            # # this code is to correct a bug in the rendering of text,
+                            # # leaving a kind of shadow around the text
+                            # del draw
+                            # if textcolor[:3] != (0, 0, 0):  # black is ok
+                            #     if False and has_numpy():
+                            #         arr = numpy.asarray(im).copy()
+                            #         arr[:, :, 0] = textcolor[0]
+                            #         arr[:, :, 1] = textcolor[1]
+                            #         arr[:, :, 2] = textcolor[2]
+                            #         im = Image.fromarray(numpy.uint8(arr))
+                            #     else:
+                            #         pix = im.load()
+                            #         for y in range(imheight):
+                            #             for x in range(imwidth):
+                            #                 pix[x, y] = (textcolor[0], textcolor[1], textcolor[2], pix[x, y][3])
+
+                            # # end of code to correct bug
+
+                            self.imwidth, self.imheight = im.size
+                            self.heightA = heightA
+
+                            self._image = im.rotate(angle, expand=1)
 
                     anchor_to_dis = {
                         "ne": (-0.5, -0.5),
@@ -25161,7 +25172,7 @@ def _check_overlapping_parameters(obj, method_name0, method_name1, process=None)
 
 @functools.lru_cache()
 def _screen_dimensions():
-    if Xlwings:
+    if pyodide:
         return 1024, 768
     if Pythonista:
         screen_width, screen_height = ui.get_screen_size()
@@ -27189,7 +27200,7 @@ def _std_fonts():
 
 
 def fonts():
-    if Xlwings:
+    if pyodide:
         return []
     if not hasattr(fonts, "font_list"):
         fonts.font_list = []
@@ -27253,6 +27264,8 @@ def standardfonts():
 
 
 def fallback_font(name, size):
+    if int(size) == 0:
+        return None, 0
     if name == "dejavusansmono":
         s = (
             "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"  # NOQA
@@ -27278,6 +27291,8 @@ def fallback_font(name, size):
 
 def getfont(fontname, fontsize):
     # fontsize in screen_coordinates!
+    if int(fontsize) == 0:
+        return None, 0
     if hasattr(getfont, "lookup"):
         if (fontname, fontsize) in getfont.lookup:
             return getfont.lookup[(fontname, fontsize)]
@@ -27462,7 +27477,7 @@ def can_animate(try_only: bool = True) -> bool:
         except ImportError:
             ImageGrab = None
 
-        if not Pythonista and not Xlwings:
+        if not Pythonista and not pyodide:
             from PIL import ImageTk
     except ImportError:
         if try_only:
@@ -27471,7 +27486,7 @@ def can_animate(try_only: bool = True) -> bool:
 
     g.dummy_image = Image.new("RGBA", (1, 1), (0, 0, 0, 0))
 
-    if not Pythonista and not Xlwings:
+    if not Pythonista and not pyodide:
         try:
             import tkinter
             import tkinter.font

{salabim-25.0.12 → salabim-25.0.14}/salabim.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: salabim
-Version: 25.0.12
+Version: 25.0.14
 Summary: salabim - discrete event simulation in Python
 Author-email: Ruud van der Ham <rt.van.der.ham@gmail.com>
 Project-URL: Homepage, https://salabim.org