salabim 24.0.12__tar.gz → 24.0.14.post3__tar.gz

{salabim-24.0.12 → salabim-24.0.14.post3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: salabim
-Version: 24.0.12
+Version: 24.0.14.post3
 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-24.0.12 → salabim-24.0.14.post3}/pyproject.toml

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

{salabim-24.0.12 → salabim-24.0.14.post3}/salabim/salabim.py

@@ -1,13 +1,13 @@
-#               _         _      _               ____   _  _        ___      _  ____
-#   ___   __ _ | |  __ _ | |__  (_) _ __ ___    |___ \ | || |      / _ \    / ||___ \
-#  / __| / _` || | / _` || '_ \ | || '_ ` _ \     __) || || |_    | | | |   | |  __) |
-#  \__ \| (_| || || (_| || |_) || || | | | | |   / __/ |__   _| _ | |_| | _ | | / __/
-#  |___/ \__,_||_| \__,_||_.__/ |_||_| |_| |_|  |_____|   |_|  (_) \___/ (_)|_||_____|
+#               _         _      _               ____   _  _        ___      _  _  _
+#   ___   __ _ | |  __ _ | |__  (_) _ __ ___    |___ \ | || |      / _ \    / || || |
+#  / __| / _` || | / _` || '_ \ | || '_ ` _ \     __) || || |_    | | | |   | || || |_
+#  \__ \| (_| || || (_| || |_) || || | | | | |   / __/ |__   _| _ | |_| | _ | ||__   _|
+#  |___/ \__,_||_| \__,_||_.__/ |_||_| |_| |_|  |_____|   |_|  (_) \___/ (_)|_|   |_|
 #                    discrete event simulation
 #
 #  see www.salabim.org for more information, the documentation and license information
 
-__version__ = "24.0.12"
+__version__ = "24.0.14"
 
 import heapq
 import random
@@ -60,7 +60,7 @@ PyDroid = sys.platform == "linux" and any("pydroid" in v for v in os.environ.val
 PyPy = platform.python_implementation() == "PyPy"
 Chromebook = "penguin" in platform.uname()
 PythonInExcel = not ("__file__" in globals())
-AnacondaCode = sys.platform=="emscripten"
+AnacondaCode = sys.platform == "emscripten"
 
 
 def a_log(*args):
@@ -154,8 +154,9 @@ nan = float("nan")
 if Pythonista or AnacondaCode or PythonInExcel:
     _yieldless = False
 else:
-    _yieldless=True
-    
+    _yieldless = True
+
+
 class QueueFullError(Exception):
     pass
 
@@ -4144,7 +4145,7 @@ if Pythonista:
                     try:
                         ims = scene.load_pil_image(capture_image)
                     except SystemError:
-                        im_file = "temp.png"  # hack for Pythonista 3.4 ***
+                        im_file = "temp.png"  # hack for Pythonista 3.4
                         capture_image.save(im_file, "PNG")
                         ims = scene.load_image_file(im_file)
                     scene.image(ims, 0, 0, *capture_image.size)
@@ -5717,7 +5718,7 @@ class Queue:
 
 class Store(Queue):
     def __init__(self, name: str = None, monitor: Any = True, fill: Iterable = None, capacity: float = inf, env: "Environment" = None, *args, **kwargs) -> None:
-        super().__init__(name=name, monitor=monitor,fill=None,capacity=capacity, env=env, *args, **kwargs)
+        super().__init__(name=name, monitor=monitor, fill=None, capacity=capacity, env=env, *args, **kwargs)
 
         with self.env.suppress_trace():
             self._to_store_requesters = Queue(f"{name}.to_store_requesters", env=env)
@@ -7981,6 +7982,10 @@ by adding:
         ----
         Only if yieldless is False: if to be used for the current component, use ``yield self.cancel()``.
         """
+        if self.status.value == data:
+            if self.env._trace:
+                self.env.print_trace("", "", "cancel (on data component) " + self.name() + " " + self._modetxt())
+            return
         if self.status.value != current:
             self._checkisnotdata()
             self._remove()
@@ -9048,10 +9053,7 @@ by adding:
             self.status._value = waiting
             self._reschedule(scheduled_time, schedule_priority, urgent, "wait", cap_now)
         else:
-            return  # ***
-            if self.env._yieldless:
-                if self is self.env._current_component:
-                    self.env._glet.switch()
+            return
 
     def _trywait(self):
         if self.status.value == interrupted:
@@ -10000,6 +10002,211 @@ by adding:
             return None
 
 
+class Event(Component):
+    """
+    Event object
+
+    An event object is a specialized Component that is usually not subclassed.
+
+    Apart from the usual Component parameters it has an action parameter, to specifies what should
+    happen after becoming active. This action is usually a lambda function.
+
+    Parameters
+    ----------
+    action : callable
+        function called when the component becomes current.
+
+    action_string : str
+        string to be printed in trace when action gets executed (default: "action")
+
+    name : str
+        name of the component.
+
+        if the name ends with a period (.),
+        auto serializing will be applied
+
+        if the name end with a comma,
+        auto serializing starting at 1 will be applied
+
+        if omitted, the name will be derived from the class
+        it is defined in (lowercased)
+
+    at : float or distribution
+        schedule time
+
+        if omitted, now is used
+
+        if distribution, the distribution is sampled
+
+    delay : float or distributiom
+        schedule with a delay
+
+        if omitted, no delay
+
+        if distribution, the distribution is sampled
+
+    priority : float
+        priority
+
+        default: 0
+
+        if a component has the same time on the event list, this component is sorted accoring to
+        the priority.
+
+    urgent : bool
+        urgency indicator
+
+        if False (default), the component will be scheduled
+        behind all other components scheduled
+        for the same time and priority
+
+        if True, the component will be scheduled
+        in front of all components scheduled
+        for the same time and priority
+
+    suppress_trace : bool
+        suppress_trace indicator
+
+        if True, this component will be excluded from the trace
+
+        If False (default), the component will be traced
+
+        Can be queried or set later with the suppress_trace method.
+
+    suppress_pause_at_step : bool
+        suppress_pause_at_step indicator
+
+        if True, if this component becomes current, do not pause when stepping
+
+        If False (default), the component will be paused when stepping
+
+        Can be queried or set later with the suppress_pause_at_step method.
+
+    skip_standby : bool
+        skip_standby indicator
+
+        if True, after this component became current, do not activate standby components
+
+        If False (default), after the component became current  activate standby components
+
+        Can be queried or set later with the skip_standby method.
+
+    mode : str preferred
+        mode
+
+        will be used in trace and can be used in animations
+
+        if omitted, the mode will be "".
+
+        also mode_time will be set to now.
+
+    cap_now : bool
+        indicator whether times (at, delay) in the past are allowed. If, so now() will be used.
+        default: sys.default_cap_now(), usualy False
+
+    env : Environment
+        environment where the component is defined
+
+        if omitted, default_env will be used
+    """
+
+    def __init__(
+        self,
+        action: Callable,
+        action_string="action",
+        name: str = None,
+        at: Union[float, Callable] = None,
+        delay: Union[float, Callable] = None,
+        priority: float = None,
+        urgent: bool = None,
+        suppress_trace: bool = False,
+        suppress_pause_at_step: bool = False,
+        skip_standby: bool = False,
+        mode: str = "",
+        cap_now: bool = None,
+        env: "Environment" = None,
+        **kwargs,
+    ):
+        self._action = action
+        self._action_string = action_string
+        self._action_taken = False
+        if env is None:
+            env = g.default_env
+        super().__init__(
+            name=name,
+            at=at,
+            delay=delay,
+            priority=priority,
+            urgent=urgent,
+            suppress_trace=suppress_trace,
+            suppress_pause_at_step=suppress_pause_at_step,
+            skip_standby=skip_standby,
+            mode=mode,
+            cap_now=cap_now,
+            env=env,
+            process="process" if env._yieldless else "process_yield",
+            **kwargs,
+        )
+
+    def process_yield(self):
+        self.env.print_trace("", "", self._action_string, "")
+        self._action()
+        self._action_taken = True
+        return
+        yield 1  # just to make it a generator
+
+    def process(self):
+        self.env.print_trace("", "", self._action_string, "")
+        self._action()
+        self._action_taken = True
+
+    def action(self, value=None):
+        """
+        action
+
+        Parameters
+        ----------
+        value : callable
+            new action callable
+
+        Returns
+        -------
+        current action : callable
+        """
+        if value is not None:
+            self._action = value
+        return self._action
+
+    def action_string(self, value=None):
+        """
+        action_string
+
+        Parameters
+        ----------
+        value : string
+            new action_string
+
+        Returns
+        -------
+        current action_string : string
+        """
+
+        if value is not None:
+            self._action_string = value
+        return self._action_string
+
+    def action_taken(self):
+        """
+        action_taken
+
+        Returns
+        -------
+        action taken: bool
+            True if action has been taken, False if not
+        """
+        return self._action_taken
+
+
 class Environment:
     """
     environment object
@@ -10791,7 +10998,7 @@ class Environment:
                 if c.overridden_lineno:
                     self.print_trace(self.time_to_str(self._now - self._offset), c.name(), "current", s0=un_na(c.overridden_lineno))
                 else:
-                    self.print_trace(self.time_to_str(self._now - self._offset), c.name(), "current", s0=un_na(c.lineno_txt()))  # ***
+                    self.print_trace(self.time_to_str(self._now - self._offset), c.name(), "current", s0=un_na(c.lineno_txt()))
             if c == self._main:
                 self.running = False
                 return
@@ -11141,13 +11348,13 @@ class Environment:
 
         if width is not None:
             if self._width != width:
-                self._width = width
+                self._width = int(width)
                 frame_changed = True
                 width_changed = True
 
         if height is not None:
             if self._height != height:
-                self._height = height
+                self._height = int(height)
                 frame_changed = True
                 height_changed = True
 
@@ -11506,7 +11713,7 @@ class Environment:
                     if self._video_pingpong:
                         self._images.extend(self._images[::-1])
                     if self._video_repeat == 1:  # in case of repeat == 1, loop should not be specified (otherwise, it might show twice)
-                        if PythonInExcel or AnacondaCode:  # ***
+                        if PythonInExcel or AnacondaCode:
                             with b64_file_handler(self._video_name, mode="b", result=_pie_result) as f:
                                 self._images[0].save(
                                     f,
@@ -11527,7 +11734,7 @@ class Environment:
                                 optimize=False,
                             )
                     else:
-                        if PythonInExcel or AnacondaCode:  # ***
+                        if PythonInExcel or AnacondaCode:
                             with b64_file_handler(self._video_name, mode="b", result=_pie_result) as f:
                                 self._images[0].save(
                                     f,
@@ -11596,7 +11803,8 @@ class Environment:
             for ao in an_objects:
                 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)
+                    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)
 
@@ -12993,7 +13201,7 @@ class Environment:
                     if co is None:
                         if len(g.canvas_objects) >= self._maximum_number_of_bitmaps:
                             if overflow_image is None:
-                                overflow_image = Image.new("RGBA", (self._width, self._height), (0, 0, 0, 0))
+                                overflow_image = Image.new("RGBA", (int(self._width), int(self._height)), (0, 0, 0, 0))
                             overflow_image.paste(ao._image, (int(ao._image_x), int(self._height - ao._image_y - ao._image.size[1])), ao._image)
                             ao.canvas_object = None
                         else:
@@ -15218,10 +15426,20 @@ class Animate2dBase(DynamicClass):
                     spec = self.image(t)
                     image_container = ImageContainer(spec)
                     width = self.width(t)
+                    height = self.height(t)
+
                     if width is None:
-                        width = image_container.images[0].size[0]
+                        if height is None:
+                            width = image_container.images[0].size[0]
+                            height = image_container.images[0].size[1]
+                        else:
+                            width = height * image_container.images[0].size[0] / image_container.images[0].size[1]
+                    else:
+                        if height is None:
+                            height = width * image_container.images[0].size[1] / image_container.images[0].size[0]
+                        else:
+                            ...
 
-                    height = width * image_container.images[0].size[1] / image_container.images[0].size[0]
                     if not self.screen_coordinates:
                         width *= self.env._scale
                         height *= self.env._scale
@@ -15240,7 +15458,6 @@ class Animate2dBase(DynamicClass):
                         offsety = offsety * self.env._scale
 
                     alpha = int(self.alpha(t))
-
                     image, id = image_container.get_image(
                         (t - self.animation_start(t)) * self.animation_speed(t),
                         repeat=self.animation_repeat(t),
@@ -15248,6 +15465,7 @@ class Animate2dBase(DynamicClass):
                         t_from=self.animation_from(t),
                         t_to=self.animation_to(t),
                     )
+
                     self._image_ident = (spec, id, width, height, angle, alpha, flip_horizontal, flip_vertical)
 
                     if self._image_ident != self._image_ident_prev:
@@ -15312,8 +15530,6 @@ class Animate2dBase(DynamicClass):
 
                     if not self.screen_coordinates:
                         fontsize = fontsize * self.env._scale
-                        # offsetx = offsetx * self.env._scale  # ***
-                        # offsety = offsety * self.env._scale  # ***
                     text_anchor = self.text_anchor(t)
 
                     if self.attached_to:
@@ -15347,6 +15563,7 @@ class Animate2dBase(DynamicClass):
                             qx = (x - self.env._x0) * self.env._scale
                             qy = (y - self.env._y0) * self.env._scale
                     max_lines = self.max_lines(t)
+
                     self._image_ident = (text, fontname, fontsize, angle, textcolor, max_lines)
                     if self._image_ident != self._image_ident_prev:
                         font, heightA = getfont(fontname, fontsize)
@@ -15529,6 +15746,9 @@ class AnimateClassic(Animate2dBase):
     def width(self, t):
         return self.master.width(t)
 
+    def height(self, t):
+        return self.master.height(t)
+
     def anchor(self, t):
         return self.master.anchor(t)
 
@@ -15756,6 +15976,11 @@ class Animate:
 
        if omitted or None, no scaling
 
+    height0 : float
+       width of the image to be displayed at time t0
+
+       if omitted or None, no scaling
+
     t1 : float
         time of end of the animation (default inf)
 
@@ -15824,6 +16049,9 @@ class Animate:
     width1 : float
        width of the image to be displayed at time t1 (default: width0)
 
+    height1 : float
+       width of the image to be displayed at time t1 (default: height0)
+
     over3d : bool
         if True, this object will be rendered to the OpenGL window
 
@@ -15892,6 +16120,7 @@ class Animate:
     font                                                                      -
     fontsize0,fontsize1                                                       -
     width0,width1                     -
+    height0,height1                   -
     ======================  ========= ========= ========= ========= ========= =========
     """
 
@@ -15927,6 +16156,7 @@ class Animate:
         alpha0: float = 255,
         fontsize0: float = 20,
         width0: float = None,
+        height0: float = None,
         t1: float = None,
         x1: float = None,
         y1: float = None,
@@ -15945,6 +16175,7 @@ class Animate:
         alpha1: float = None,
         fontsize1: float = None,
         width1: float = None,
+        height1: float = None,
         xy_anchor: str = "",
         over3d: bool = None,
         flip_horizontal: bool = False,
@@ -15991,10 +16222,12 @@ class Animate:
         self.text0 = text
 
         if image is None:
-            self.width0 = 0  # just to be able to interpolate
+            self.width0 = 0  # just to be able to interpolat
+            self.height0 = 0
         else:
             self.image0 = image
             self.width0 = width0  # None means original size
+            self.height0 = height0
 
         self.as_points0 = as_points
         self.font0 = font
@@ -16056,7 +16289,7 @@ class Animate:
         self.alpha1 = self.alpha0 if alpha1 is None else alpha1
         self.fontsize1 = self.fontsize0 if fontsize1 is None else fontsize1
         self.width1 = self.width0 if width1 is None else width1
-
+        self.height1 = self.height0 if height1 is None else height1
         self.t1 = inf if t1 is None else t1
         if self.env._animate_debug:
             self.caller = self.env._frame_to_lineno(_get_caller_frame(), add_filename=True)
@@ -16115,6 +16348,7 @@ class Animate:
         alpha0=None,
         fontsize0=None,
         width0=None,
+        height0=None,
         xy_anchor1=None,
         as_points=None,
         t1=None,
@@ -16135,6 +16369,7 @@ class Animate:
         alpha1=None,
         fontsize1=None,
         width1=None,
+        height1=None,
         flip_horizontal=None,
         flip_vertical=None,
         animation_start=None,
@@ -16287,6 +16522,11 @@ class Animate:
 
             if None, the original width of the image will be used
 
+        height0 : float
+            height of the image to be displayed at time t0 (default see below)
+
+            if None, the original height of the image will be used
+
         t1 : float
             time of end of the animation (default: inf)
 
@@ -16353,6 +16593,8 @@ class Animate:
         width1 : float
            width of the image to be displayed at time t1 (default: width0)
 
+        height1 : float
+           height of the image to be displayed at time t1 (default: height0)
 
         Note
         ----
@@ -16388,6 +16630,8 @@ class Animate:
             self.max_lines0 = max_lines
 
         self.width0 = self.width() if width0 is None else width0
+        self.height0 = self.height() if height0 is None else height0
+
         if image is not None:
             self.image0 = image
 
@@ -16434,6 +16678,7 @@ class Animate:
         self.alpha1 = self.alpha0 if alpha1 is None else alpha1
         self.fontsize1 = self.fontsize0 if fontsize1 is None else fontsize1
         self.width1 = self.width0 if width1 is None else width1
+        self.height1 = self.height0 if height1 is None else height1
         self.xy_anchor1 = self.xy_anchor0 if xy_anchor1 is None else xy_anchor1
 
         self.t1 = inf if t1 is None else t1
@@ -16731,7 +16976,7 @@ class Animate:
 
     def width(self, t=None):
         """
-        width position of an animated image object. May be overridden.
+        width of an animated image object. May be overridden.
 
         Parameters
         ----------
@@ -16756,6 +17001,33 @@ class Animate:
 
         return interpolate((self.env._now if t is None else t), self.t0, self.t1, width0, width1)
 
+    def height(self, t=None):
+        """
+        height of an animated image object. May be overridden.
+
+        Parameters
+        ----------
+        t : float
+            current time
+
+        Returns
+        -------
+        height : float
+            default behaviour: linear interpolation between self.height0 and self.height1
+
+            if None, the original height of the image will be used
+        """
+        height0 = self.height0
+        height1 = self.height1
+        if height0 is None and height1 is None:
+            return None
+        if height0 is None:
+            height0 = ImageContainer(self.image0).images[0].size[0]
+        if height1 is None:
+            height1 = ImageContainer(self.image1).images[0].size[0]
+
+        return interpolate((self.env._now if t is None else t), self.t0, self.t1, height0, height1)
+
     def fontsize(self, t=None):
         """
         fontsize of an animate object. May be overridden.
@@ -19449,6 +19721,8 @@ class AnimateImage(Animate2dBase):
     width : float
        width of the image (default: None = no scaling)
 
+    heighth : float
+       height of the image (default: None = no scaling)
 
     text : str, tuple or list
         the text to be displayed
@@ -19584,6 +19858,7 @@ class AnimateImage(Animate2dBase):
         x: Union[float, Callable] = None,
         y: Union[float, Callable] = None,
         width: Union[float, Callable] = None,
+        height: Union[float, Callable] = None,
         text: Union[str, Callable] = None,
         fontsize: Union[float, Callable] = None,
         textcolor: Union[ColorType, Callable] = None,
@@ -19626,6 +19901,7 @@ class AnimateImage(Animate2dBase):
                 x=0,
                 y=0,
                 width=None,
+                height=None,
                 text="",
                 fontsize=15,
                 textcolor="bg",
@@ -19708,10 +19984,10 @@ class ComponentGenerator(Component):
 
     Parameters
     ----------
-    component_class : callable, usually a subclass of Component or Pdf or Cdf distribution
+    component_class : callable, usually a subclass of Component or Pdf/Pmf or Cdf distribution
         the type of components to be generated
 
-        in case of a distribution, the Pdf or Cdf should return a callable
+        in case of a distribution, the Pdf/Pmf or Cdf should return a callable
 
     generator_name : str
         name of the component generator.
@@ -19822,6 +20098,13 @@ class ComponentGenerator(Component):
 
         e.g. env.main().activate()
 
+    moments : iterable
+        specifies the moments when the components have to be generated. It is not required that these are sorted.
+
+        note that the moments are specified in the current time unit
+
+        cannot be used together with at, delay, till, duration, number, iat,force_at, force_till, disturbance or equidistant
+
     env : Environment
         environment where the component is defined
 
@@ -19850,6 +20133,7 @@ class ComponentGenerator(Component):
         disturbance: Callable = None,
         equidistant: bool = False,
         at_end: Callable = None,
+        moments: Iterable = None,
         env: "Environment" = None,
         **kwargs,
     ):
@@ -19867,6 +20151,15 @@ class ComponentGenerator(Component):
 
         if not callable(component_class):
             raise ValueError("component_class must be a callable")
+        if moments is not None:
+            if any(prop for prop in (at, delay, till, duration, number, iat, force_at, force_till, disturbance, equidistant)):
+                raise ValueError(
+                    "specifying at, delay, till,duration, number, iat,force_at, force_till, disturbance or equidistant is not allowed, if moments is specified"
+                )
+            if callable(moments):
+                moments = moments()
+            moments = sorted([env.spec_to_time(moment) for moment in moments])
+
         self.component_class = component_class
         self.iat = iat
         self.disturbance = disturbance
@@ -19909,25 +20202,26 @@ class ComponentGenerator(Component):
             at = None
             process = ""
         else:
-            if self.iat is None and not equidistant:
-                if till == inf or self.number == inf:
-                    raise ValueError("iat not specified --> till and number need to be specified")
-                if disturbance is not None:
-                    raise ValueError("iat not specified --> disturbance not allowed")
-
-                samples = sorted([Uniform(at, till)() for _ in range(self.number)])
-                if force_at or force_till:
-                    if number == 1:
-                        if force_at and force_till:
-                            raise ValueError("force_at and force_till does not allow number=1")
-                        samples = [at] if force_at else [till]
-                    else:
-                        v_at = at if force_at else samples[0]
-                        v_till = till if force_till else samples[-1]
-                        min_sample = samples[0]
-                        max_sample = samples[-1]
-                        samples = [interpolate(sample, min_sample, max_sample, v_at, v_till) for sample in samples]
-                self.intervals = [t1 - t0 for t0, t1 in zip([0] + samples, samples)]
+            if (self.iat is None and not equidistant) or moments:
+                if not moments:
+                    if till == inf or self.number == inf:
+                        raise ValueError("iat not specified --> till and number need to be specified")
+                    if disturbance is not None:
+                        raise ValueError("iat not specified --> disturbance not allowed")
+
+                    moments = sorted([Uniform(at, till)() for _ in range(self.number)])
+                    if force_at or force_till:
+                        if number == 1:
+                            if force_at and force_till:
+                                raise ValueError("force_at and force_till does not allow number=1")
+                            moments = [at] if force_at else [till]
+                        else:
+                            v_at = at if force_at else moments[0]
+                            v_till = till if force_till else moments[-1]
+                            min_moment = moments[0]
+                            max_moment = moments[-1]
+                            moments = [interpolate(moment, min_moment, max_moment, v_at, v_till) for moment in moments]
+                self.intervals = [t1 - t0 for t0, t1 in zip([0] + moments, moments)]
                 at = self.intervals[0]
                 self.intervals[0] = 0
                 process = "do_spread_yieldless" if env._yieldless else "do_spread"
@@ -20253,7 +20547,7 @@ class _Distribution:
         If, after number_of_tries retries, the sampled value is still not within the given bounds,
         fail_value  will be returned
 
-        Samples that cannot be converted (only possible with Pdf and CumPdf) to float
+        Samples that cannot be converted (only possible with /Pmf and CumPdf/CumPmf) to float
         are assumed to be within the bounds.
         """
         return Bounded(self, lowerbound, upperbound, fail_value, number_of_retries, include_lowerbound, include_upperbound).sample()
@@ -20493,7 +20787,7 @@ class Bounded(_Distribution):
     If, after number_of_tries retries, the sampled value is still not within the given bounds,
     fail_value  will be returned
 
-    Samples that cannot be converted to float (only possible with Pdf and CumPdf)
+    Samples that cannot be converted to float (only possible with Pdf/Pmf and CumPdf)
     are assumed to be within the bounds.
     """
 
@@ -21989,6 +22283,9 @@ class Pdf(_Distribution):
 
     If it is a salabim distribution, not the distribution,
     but a sample will be returned when calling sample.
+
+
+    This method is also available under the name Pmf
     """
 
     def __init__(self, spec: Union[Iterable, Dict], probabilities=None, time_unit: str = None, randomstream: Any = None, env: "Environment" = None):
@@ -22133,9 +22430,151 @@ class Pdf(_Distribution):
         return self._mean
 
 
+class Pmf(Pdf):
+    """
+    Probability mass function
+
+    Parameters
+    ----------
+    spec : list, tuple or dict
+        either
+
+        -   if no probabilities specified:
+
+            list/tuple with x-values and corresponding probability
+            dict where the keys are re x-values and the values are probabilities
+            (x0, p0, x1, p1, ...xn,pn)
+
+        -   if probabilities is specified:
+
+            list with x-values
+
+    probabilities : iterable or float
+        if omitted, spec contains the probabilities
+
+        the iterable (p0, p1, ...pn) contains the probabilities of the corresponding
+        x-values from spec.
+
+        alternatively, if a float is given (e.g. 1), all x-values
+        have equal probability. The value is not important.
+
+    time_unit : str
+        specifies the time unit
+
+        must be one of "years", "weeks", "days", "hours", "minutes", "seconds", "milliseconds", "microseconds"
+
+        default : no conversion
+
+
+    randomstream : randomstream
+        if omitted, random will be used
+
+        if used as random.Random(12299)
+        it assigns a new stream with the specified seed
+
+    env : Environment
+        environment where the distribution is defined
+
+        if omitted, default_env will be used
+
+    Note
+    ----
+    p0+p1=...+pn>0
+
+    all densities are auto scaled according to the sum of p0 to pn,
+    so no need to have p0 to pn add up to 1 or 100.
+
+    The x-values can be any type.
+
+    If it is a salabim distribution, not the distribution,
+    but a sample will be returned when calling sample.
+
+    This method is also available under the name Pdf
+
+    """
+
+    def __repr__(self):
+        return "Pmf"
+
+    def print_info(self, as_str: bool = False, file: TextIO = None) -> str:
+        """
+        prints information about the distribution
+
+        Parameters
+        ----------
+        as_str: bool
+            if False (default), print the info
+            if True, return a string containing the info
+
+        file: file
+            if None(default), all output is directed to stdout
+
+            otherwise, the output is directed to the file
+
+        Returns
+        -------
+        info (if as_str is True) : str
+        """
+        result = []
+        result.append("Pmf distribution " + hex(id(self)))
+        result.append("  randomstream=" + hex(id(self.randomstream)))
+        return return_or_print(result, as_str, file)
+
+    def sample(self, n: int = None) -> Any:
+        """
+        Parameters
+        ----------
+        n : number of samples : int
+            if not specified, specifies just return one sample, as usual
+
+            if specified, return a list of n sampled values from the distribution without replacement.
+            This requires that all probabilities are equal.
+
+            If n > number of values in the Pmf distribution, n is assumed to be the number of values
+            in the distribution.
+
+            If a sampled value is a distribution, a sample from that distribution will be returned.
+
+        Returns
+        -------
+        Sample of the distribution : any (usually float) or list
+            In case n is specified, returns a list of n values
+
+        """
+        if self.supports_n:
+            if n is None:
+                return self.randomstream.sample(self._x, 1)[0]
+            else:
+                if n < 0:
+                    raise ValueError("n < 0")
+                n = min(n, len(self._x))
+                xs = self.randomstream.sample(self._x, n)
+                return [x.sample() if isinstance(x, _Distribution) else x for x in xs]
+        else:
+            if n is None:
+                r = self.randomstream.random()
+                for cum, x in zip([0] + self._cum, [0] + self._x):
+                    if r <= cum:
+                        if isinstance(x, _Distribution):
+                            return x.sample()
+                        return x
+            else:
+                raise ValueError("not all probabilities are the same")
+
+    def mean(self) -> float:
+        """
+        Returns
+        -------
+        mean of the distribution : float
+            if the mean can't be calculated (if not all x-values are scalars or distributions),
+            nan will be returned.
+        """
+        return self._mean
+
+
 class CumPdf(_Distribution):
     """
-    Cumulative Probability distribution function
+    Cumulative Probability mass function
 
     Parameters
     ----------
@@ -22188,6 +22627,8 @@ class CumPdf(_Distribution):
 
     If it is a salabim distribution, not the distribution,
     but a sample will be returned when calling sample.
+
+    This method is also available under the name CumPmf
     """
 
     def __init__(
@@ -22303,6 +22744,116 @@ class CumPdf(_Distribution):
         return self._mean
 
 
+class CumPmf(CumPdf):
+    """
+    Cumulative Probability mass function
+
+    Parameters
+    ----------
+    spec : list or tuple
+        either
+
+        -   if no cumprobabilities specified:
+
+            list with x-values and corresponding cumulative probability
+            (x0, p0, x1, p1, ...xn,pn)
+
+        -   if cumprobabilities is specified:
+
+            list with x-values
+
+    cumprobabilities : list, tuple or float
+        if omitted, spec contains the probabilities
+
+        the list (p0, p1, ...pn) contains the cumulative probabilities of the corresponding
+        x-values from spec.
+
+
+    time_unit : str
+        specifies the time unit
+
+        must be one of "years", "weeks", "days", "hours", "minutes", "seconds", "milliseconds", "microseconds"
+
+        default : no conversion
+
+
+    randomstream : randomstream
+        if omitted, random will be used
+
+        if used as random.Random(12299)
+        it assigns a new stream with the specified seed
+
+    env : Environment
+        environment where the distribution is defined
+
+        if omitted, default_env will be used
+
+    Note
+    ----
+    p0<=p1<=..pn>0
+
+    all densities are auto scaled according to pn,
+    so no need to have pn be 1 or 100.
+
+    The x-values can be any type.
+
+    If it is a salabim distribution, not the distribution,
+    but a sample will be returned when calling sample.
+
+    This method is also available under the name CumPdf
+    """
+
+    def __repr__(self):
+        return "CumPmf"
+
+    def print_info(self, as_str: bool = False, file: TextIO = None) -> str:
+        """
+        prints information about the distribution
+
+        Parameters
+        ----------
+        as_str: bool
+            if False (default), print the info
+            if True, return a string containing the info
+
+        file: file
+            if None(default), all output is directed to stdout
+
+            otherwise, the output is directed to the file
+
+        Returns
+        -------
+        info (if as_str is True) : str
+        """
+        result = []
+        result.append("CumPmf distribution " + hex(id(self)))
+        result.append("  randomstream=" + hex(id(self.randomstream)))
+        return return_or_print(result, as_str, file)
+
+    def sample(self) -> Any:
+        """
+        Returns
+        -------
+        Sample of the distribution : any (usually float)
+        """
+        r = self.randomstream.random()
+        for cum, x in zip([0] + self._cum, [0] + self._x):
+            if r <= cum:
+                if isinstance(x, _Distribution):
+                    return x.sample()
+                return x
+
+    def mean(self) -> float:
+        """
+        Returns
+        -------
+        mean of the distribution : float
+            if the mean can't be calculated (if not all x-values are scalars or distributions),
+            nan will be returned.
+        """
+        return self._mean
+
+
 class External(_Distribution):
     """
     External distribution function
@@ -23902,7 +24453,7 @@ class _APNG:
 
     def to_bytes(self):
         CHUNK_BEFORE_IDAT = {"cHRM", "gAMA", "iCCP", "sBIT", "sRGB", "bKGD", "hIST", "tRNS", "pHYs", "sPLT", "tIME", "PLTE"}
-        PNG_SIGN = b"\x89\x50\x4E\x47\x0D\x0A\x1A\x0A"
+        PNG_SIGN = b"\x89\x50\x4e\x47\x0d\x0a\x1a\x0a"
         out = [PNG_SIGN]
         other_chunks = []
         seq = 0
@@ -26316,7 +26867,7 @@ def fonts():
 
         for dir, recursive in dir_recursives:
             for file_path in dir.glob("**/*.*" if recursive else "*.*"):
-                if file_path.suffix.lower() == ".ttf":  # ***
+                if file_path.suffix.lower() == ".ttf":
                     file = str(file_path)
                     fn = os.path.basename(file).split(".")[0]
                     if "_std_fonts" in globals() and fn in _std_fonts():  # test for availabiitly, because of minimized version
@@ -26376,7 +26927,8 @@ def getfont(fontname, fontsize):
             return getfont.lookup[(fontname, fontsize)]
     else:
         getfont.lookup = {}
-
+    if fontname == "":
+        a = 1
     if isinstance(fontname, str):
         fontlist1 = [fontname]
     else:
@@ -26409,7 +26961,8 @@ def getfont(fontname, fontsize):
                     result = ImageFont.truetype(filename, size=int(fontsize))
                 else:
                     #  refer to https://github.com/python-pillow/Pillow/issues/3730 for explanation (in order to load >= 500 fonts)
-                    result = ImageFont.truetype(font=io.BytesIO(open(filename, "rb").read()), size=int(fontsize))
+                    with open(filename, "rb") as f:
+                        result = ImageFont.truetype(font=io.BytesIO(f.read()), size=int(fontsize))
                 break
             except Exception:
                 raise
@@ -26948,7 +27501,7 @@ def reset() -> None:
     g.tkinter_loaded = "?"
     g.image_container_cache = {}
     g._default_cap_now = False
-    g._captured_stdout=[]
+    g._captured_stdout = []
 
     random_seed()  # always start with seed 1234567
 
@@ -27181,7 +27734,6 @@ reset()
 set_environment_aliases()
 
 if __name__ == "__main__":
-
     sys.path.insert(0, str(Path(__file__).parent / ".." / "misc"))
     try:
         import salabim_exp

{salabim-24.0.12 → salabim-24.0.14.post3}/salabim.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: salabim
-Version: 24.0.12
+Version: 24.0.14.post3
 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-24.0.12 → salabim-24.0.14.post3}/tests/test_componentgenerator.py

@@ -1,5 +1,15 @@
-import salabim as sim
 import pytest
+from pathlib import Path
+import sys
+import os
+
+if __name__ == "__main__":
+    file_folder = Path(__file__).parent
+    top_folder = (file_folder / "..").resolve()
+    sys.path.insert(0, str(top_folder))
+    os.chdir(file_folder)
+
+import salabim as sim
 
 
 class X(sim.Component):
@@ -190,9 +200,21 @@ def test_dis():
     for component in components:
         names.tally(component.name().split(".")[0])
 
+def test_moments():
+    moments=(1,2,3,4,100,5)
+    components = exp(X, moments=moments)
+    assert components[0].enter_time(components) == 1
+    assert components[1].enter_time(components) == 2
+    assert components[2].enter_time(components) == 3
+    assert components[3].enter_time(components) == 4
+    assert components[4].enter_time(components) == 5
+    assert components[5].enter_time(components) == 100
+
+
 
 #    names.print_histogram(values=True, sort_on_weight=True)
 
 if __name__ == "__main__":
-    pytest.main(["-vv", "-s", __file__])
+    pytest.main(["-vv", "-s",__file__])
+
 

{salabim-24.0.12 → salabim-24.0.14.post3}/tests/test_distributions.py

@@ -1,7 +1,16 @@
-import salabim as sim
 import pytest
 import collections
+from pathlib import Path
+import os
+import sys
 
+if __name__ == "__main__":
+    file_folder = Path(__file__).parent
+    top_folder = (file_folder / "..").resolve()
+    sys.path.insert(0, str(top_folder))
+    os.chdir(file_folder)
+
+import salabim as sim
 
 def collect(dis, n=10000):
     m = sim.Monitor()
@@ -85,11 +94,13 @@ def test_int_uniform():
     assert set(m.x()) == {1, 2, 3, 4, 5, 6}
     count = collections.Counter(m.x())
     for v, n in count.items():
-        assert n == pytest.approx(10000 / 6, rel=1e-1)
+        assert n == pytest.approx(10000 / 6, rel=10)
 
 
 def test_pdf():
     env = sim.Environment()
+    d=sim.Pdf((1,10,2,70,3,20))
+    assert str(d)=="Pdf"
     m = collect(sim.Pdf((1,10,2,70,3,20)))
     assert m.mean() == pytest.approx(2.1, rel=1e-2)
     m = collect(sim.Pdf((1,2,3),(10,70,20)))
@@ -100,6 +111,36 @@ def test_pdf():
     m = collect(sim.Pdf(d))
     assert m.mean() == pytest.approx(2.1, rel=1e-2)
 
+
+def test_pmf():
+    env = sim.Environment()
+    d=sim.Pmf((1,10,2,70,3,20))
+    assert str(d)=="Pmf"    
+    m = collect(sim.Pmf((1,10,2,70,3,20)))
+    assert m.mean() == pytest.approx(2.1, rel=1e-2)
+    m = collect(sim.Pmf((1,2,3),(10,70,20)))
+    assert m.mean() == pytest.approx(2.1, rel=1e-2)
+    d = {1:10, 2:70, 3:20}
+    m = collect(sim.Pmf(d.keys(),d.values()))
+    assert m.mean() == pytest.approx(2.1, rel=1e-2)
+    m = collect(sim.Pmf(d))
+    assert m.mean() == pytest.approx(2.1, rel=1e-2)
+
+def test_cumpdf():
+    env = sim.Environment()
+    d=sim.CumPdf((1, 10, 2, 80, 3,100))
+    assert str(d)=="CumPdf"
+    m = collect(d)
+    assert m.mean() == pytest.approx(2, rel=1e-1)
+
+def test_cumpmf():
+    env = sim.Environment()
+    d=sim.CumPmf((1, 10, 2, 80, 3,100))
+    assert str(d)=="CumPmf"
+    m = collect(d)
+    assert m.mean() == pytest.approx(2, rel=1e-1)
+
+
 def test_scipy_distribution():
     try:
         import scipy.stats as st