pathsim 0.25.0__tar.gz → 0.25.1__tar.gz

{pathsim-0.25.0 → pathsim-0.25.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pathsim
-Version: 0.25.0
+Version: 0.25.1
 Summary: A differentiable block based hybrid system simulation framework.
 Author-email: Milan Rother <milan.rother@gmx.de>
 License: MIT

{pathsim-0.25.0 → pathsim-0.25.1}/src/pathsim/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.25.0'
-__version_tuple__ = version_tuple = (0, 25, 0)
+__version__ = version = '0.25.1'
+__version_tuple__ = version_tuple = (0, 25, 1)
 
-__commit_id__ = commit_id = 'g405501720'
+__commit_id__ = commit_id = 'gea36c5c1e'

{pathsim-0.25.0 → pathsim-0.25.1}/src/pathsim/utils/graph.py

@@ -606,8 +606,10 @@ class Graph:
     def _has_algebraic_self_loop(self, block):
         """Check if a block has an algebraic path back to itself.
 
-        For self-loops, verifies that the path actually leaves the block and
-        returns through other algebraic blocks (not just a direct self-connection).
+        The path leaves the block and returns through algebraic blocks. The
+        block itself only bounds the path, so it doesn't have to be algebraic.
+        This is the case for the 'Interface' of a 'Subsystem', where a path
+        back to itself is an algebraic passthrough of the subsystem.
 
         Parameters
         ----------
@@ -619,18 +621,14 @@ class Graph:
         bool
             True if an algebraic self-loop exists, False otherwise
         """
-        # Check if block is algebraic
-        if block in self._dyn_blocks:
-            return False
-        
         # Get immediate neighbors
         neighbors = self._dnst_blk_blk_map[block]
-        
+
         if not neighbors:
             return False
-        
+
         # BFS from neighbors to see if any path back
-        visited = {block}  # Don't revisit start immediately
+        visited = set()
         stack = list(neighbors)
         
         while stack:

{pathsim-0.25.0 → pathsim-0.25.1}/src/pathsim.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pathsim
-Version: 0.25.0
+Version: 0.25.1
 Summary: A differentiable block based hybrid system simulation framework.
 Author-email: Milan Rother <milan.rother@gmx.de>
 License: MIT

pathsim-0.25.1/src/pathsim.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "0.25.1",
+  "distance": 0,
+  "node": "gea36c5c1efee47ed8af2020c50e749cedcd6972d",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-09-17"
+}

{pathsim-0.25.0 → pathsim-0.25.1}/tests/pathsim/test_subsystem.py

@@ -15,9 +15,11 @@ import numpy as np
 from pathsim.subsystem import Subsystem, Interface
 
 #for testing
-from pathsim.blocks import Block
+from pathsim.blocks import Block, Integrator, Amplifier, Constant, Scope
 from pathsim.blocks.dynsys import DynamicalSystem
 from pathsim.connection import Connection
+from pathsim.simulation import Simulation
+from pathsim.solvers import SSPRK22
 
 
 # TESTS ================================================================================
@@ -220,12 +222,12 @@ class TestSubsystem(unittest.TestCase):
         C1 = Connection(I1, B1)
         C2 = Connection(B1, I1)
         S = Subsystem(
-            blocks=[I1, B1], 
+            blocks=[I1, B1],
             connections=[C1, C2]
-            ) 
+            )
 
-        #should be 1
-        self.assertEqual(len(S), 0)
+        #algebraic passthrough from the subsystem inputs to its outputs
+        self.assertEqual(len(S), 1)
 
 
     def test_call(self):
@@ -433,9 +435,70 @@ class TestSubsystem(unittest.TestCase):
         S = Subsystem(blocks=[I1, B1], connections=[C1, C2])
 
         # Interface has algebraic path to itself
+        self.assertEqual(len(S), 1)
+
+
+    def test_len_dynamic_interior(self):
+        """A dynamic block on the only path breaks the passthrough"""
+        I1 = Interface()
+        B1 = Block()
+        I2 = Integrator()
+
+        S = Subsystem(
+            blocks=[I1, B1, I2],
+            connections=[Connection(I1, B1), Connection(B1, I2), Connection(I2, I1)]
+            )
+
         self.assertEqual(len(S), 0)
 
 
+    def test_len_direct_passthrough(self):
+        """A direct connection from the interface to itself is a passthrough"""
+        I1 = Interface()
+        S = Subsystem(blocks=[I1], connections=[Connection(I1, I1)])
+
+        self.assertEqual(len(S), 1)
+
+
+    def test_len_no_return_path(self):
+        """Inputs that never reach the outputs are no passthrough"""
+        I1 = Interface()
+        B1 = Block()
+        S = Subsystem(blocks=[I1, B1], connections=[Connection(I1, B1)])
+
+        self.assertEqual(len(S), 0)
+
+
+    def test_passthrough_series_without_delay(self):
+        """Purely algebraic subsystems in series introduce no delay,
+        see pathsim issue #251"""
+
+        def make_gain(g):
+            I1 = Interface()
+            A1 = Amplifier(g)
+            return Subsystem(
+                blocks=[I1, A1],
+                connections=[Connection(I1, A1), Connection(A1, I1)]
+                )
+
+        C1 = Constant(1.0)
+        G1 = make_gain(2.0)
+        G2 = make_gain(5.0)
+        Sc = Scope()
+
+        Sim = Simulation(
+            blocks=[C1, G1, G2, Sc],
+            connections=[Connection(C1, G1), Connection(G1, G2), Connection(G2, Sc)],
+            Solver=SSPRK22,
+            dt=0.01,
+            log=False
+            )
+        Sim.run(0.05)
+
+        _, [y] = Sc.read()
+        np.testing.assert_array_almost_equal(y, np.full_like(y, 10.0))
+
+
     def test_graph(self): pass
     def test_nesting(self): pass
 

{pathsim-0.25.0 → pathsim-0.25.1}/tests/pathsim/utils/test_graph.py

@@ -246,6 +246,45 @@ class TestGraph(unittest.TestCase):
         self.assertTrue(g.is_algebraic_path(self.add2, self.amp1))
         self.assertTrue(g.is_algebraic_path(self.amp1, self.add2))
 
+        # A block in the loop has an algebraic path back to itself
+        self.assertTrue(g.is_algebraic_path(self.add2, self.add2))
+        self.assertTrue(g.is_algebraic_path(self.amp1, self.amp1))
+
+
+    def test_is_algebraic_path_self_loop_dynamic(self):
+        """Test is_algebraic_path does not report loops through dynamic blocks."""
+
+        g = Graph(self.nodes_dyn_loop, self.conns_dyn_loop)
+
+        # Loop: int1 -> int2 -> int1, broken by the integrators
+        self.assertFalse(g.is_algebraic_path(self.int1, self.int1))
+
+
+    def test_is_algebraic_path_direct_self_connection(self):
+        """Test is_algebraic_path with a direct self-connection."""
+
+        amp = Amplifier(gain=2)
+        g = Graph([amp], [Connection(amp, amp)])
+
+        self.assertTrue(g.is_algebraic_path(amp, amp))
+
+
+    def test_is_algebraic_path_self_loop_bounding_block(self):
+        """Test is_algebraic_path where the block bounding the self-loop is 
+        not algebraic, like the 'Interface' of a 'Subsystem'."""
+
+        # Algebraic return path
+        itg = Integrator()
+        amp = Amplifier(gain=2)
+        g = Graph([itg, amp], [Connection(itg, amp), Connection(amp, itg)])
+        self.assertTrue(g.is_algebraic_path(itg, itg))
+
+        # No return path
+        itg = Integrator()
+        amp = Amplifier(gain=2)
+        g = Graph([itg, amp], [Connection(itg, amp)])
+        self.assertFalse(g.is_algebraic_path(itg, itg))
+
 
     def test_is_algebraic_path_no_connection(self):
         """Test is_algebraic_path with unconnected blocks."""

pathsim-0.25.0/src/pathsim.egg-info/scm_version.json

@@ -1,8 +0,0 @@
-{
-  "tag": "0.25.0",
-  "distance": 0,
-  "node": "g405501720e95b6d30a5d958ec4e373a227fe103c",
-  "dirty": false,
-  "branch": "HEAD",
-  "node_date": "2026-08-17"
-}