modularitypruning 1.4.1__tar.gz → 1.5.1__tar.gz

{modularitypruning-1.4.1 → modularitypruning-1.5.1}/PKG-INFO

@@ -1,21 +1,21 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: modularitypruning
-Version: 1.4.1
+Version: 1.5.1
 Summary: Pruning tool to identify small subsets of network partitions that are significant from the perspective of stochastic block model inference.
-Home-page: https://github.com/ragibson/ModularityPruning
-Author: Ryan Gibson
-Author-email: ryan.alex.gibson@gmail.com
+Author-email: Ryan Gibson <ryan.alex.gibson@gmail.com>
+License-Expression: MIT
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Topic :: Scientific/Engineering :: Information Analysis
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
 Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: License :: OSI Approved :: MIT License
-Requires-Python: >=3.8, <4
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: leidenalg
@@ -27,6 +27,7 @@ Requires-Dist: scikit-learn
 Requires-Dist: scipy>=1.7
 Requires-Dist: seaborn
 Requires-Dist: tqdm
+Dynamic: license-file
 
 # ModularityPruning
 

{modularitypruning-1.4.1 → modularitypruning-1.5.1}/modularitypruning.egg-info/PKG-INFO

@@ -1,21 +1,21 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: modularitypruning
-Version: 1.4.1
+Version: 1.5.1
 Summary: Pruning tool to identify small subsets of network partitions that are significant from the perspective of stochastic block model inference.
-Home-page: https://github.com/ragibson/ModularityPruning
-Author: Ryan Gibson
-Author-email: ryan.alex.gibson@gmail.com
+Author-email: Ryan Gibson <ryan.alex.gibson@gmail.com>
+License-Expression: MIT
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Topic :: Scientific/Engineering :: Information Analysis
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
 Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: License :: OSI Approved :: MIT License
-Requires-Python: >=3.8, <4
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: leidenalg
@@ -27,6 +27,7 @@ Requires-Dist: scikit-learn
 Requires-Dist: scipy>=1.7
 Requires-Dist: seaborn
 Requires-Dist: tqdm
+Dynamic: license-file
 
 # ModularityPruning
 

{modularitypruning-1.4.1 → modularitypruning-1.5.1}/modularitypruning.egg-info/SOURCES.txt

@@ -1,6 +1,6 @@
 LICENSE
 README.md
-setup.py
+pyproject.toml
 modularitypruning.egg-info/PKG-INFO
 modularitypruning.egg-info/SOURCES.txt
 modularitypruning.egg-info/dependency_links.txt

modularitypruning-1.5.1/pyproject.toml

@@ -0,0 +1,48 @@
+[build-system]
+requires = ["setuptools >= 75.3.2"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "modularitypruning"
+version = "1.5.1"
+description = "Pruning tool to identify small subsets of network partitions that are significant from the perspective of stochastic block model inference."
+readme = "README.md"
+requires-python = ">=3.9"
+license = "MIT"
+authors = [
+    { name = "Ryan Gibson", email = "ryan.alex.gibson@gmail.com" }
+]
+
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Topic :: Scientific/Engineering :: Information Analysis",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Programming Language :: Python :: 3.15",
+    "Programming Language :: Python :: 3 :: Only"
+]
+dependencies = [
+    "leidenalg",
+    "matplotlib",
+    "numpy",
+    "psutil",
+    "igraph",
+    "scikit-learn",
+    "scipy>=1.7",
+    "seaborn",
+    "tqdm"
+]
+
+[tool.setuptools]
+packages = ["modularitypruning"]
+
+[tool.setuptools.package-dir]
+modularitypruning = "utilities"
+
+[tool.autopep8]
+max_line_length = 120

{modularitypruning-1.4.1 → modularitypruning-1.5.1}/tests/test_monolayer_parameter_estimation.py

@@ -21,11 +21,11 @@ class TestMonolayerParameterEstimation(unittest.TestCase):
 
         for q in range(3, 15):
             community_sizes = [250] * q  # q equally sized groups of 250 nodes
-            n = 250 * q
+            n = sum(community_sizes)
             p_in = 16 * n / (q * 250 * 249)  # ~16 in-edges per node
             p_out = 8 * n / (q * (q - 1) * 250 * 250)  # ~8 out-edges per node to each community
             pref_matrix = [[p_in if i == j else p_out for j in range(q)] for i in range(q)]
-            G = ig.Graph.SBM(n, pref_matrix, community_sizes)
+            G = ig.Graph.SBM(pref_matrix, community_sizes)
 
             # compute "ground truth" gamma estimate
             k = mean(all_degrees(G))

{modularitypruning-1.4.1 → modularitypruning-1.5.1}/tests/test_temporal_multilevel_parameter_estimation.py

@@ -27,7 +27,7 @@ class TestTemporalAndMultilevelParameterEstimation(unittest.TestCase):
         return G_intralayer, G_interlayer, layer_membership
 
     def assert_temporal_SBM_correct_convergence(self, first_layer_membership, copying_probability=0.75, num_layers=25,
-                                                p_in=0.25, p_out=0.05):
+                                                p_in=0.25, p_out=0.05, tolerance=0.1):
         K = num_communities(first_layer_membership)
         G_intralayer, G_interlayer, layer_membership = self.generate_temporal_SBM(copying_probability, p_in, p_out,
                                                                                   first_layer_membership,
@@ -49,41 +49,78 @@ class TestTemporalAndMultilevelParameterEstimation(unittest.TestCase):
                                                                                model='temporal')
 
         # check we converged close to the ground truth "correct" values
-        self.assertLess(abs(true_gamma - gamma), 0.05)
-        self.assertLess(abs(true_omega - omega), 0.1)
+        self.assertLess(abs(true_gamma - gamma), tolerance)
+        self.assertLess(abs(true_omega - omega), tolerance)
 
         # check multilevel parameter estimation as well
         # we never use this model, but it is a slight generalization of the temporal one
         gamma, omega, _ = iterative_multilayer_resolution_parameter_estimation(G_intralayer, G_interlayer,
                                                                                layer_membership, gamma=1.0, omega=1.0,
                                                                                model='multilevel')
-        self.assertLess(abs(true_gamma - gamma), 0.05)
-        self.assertLess(abs(true_omega - omega), 0.1)
+        self.assertLess(abs(true_gamma - gamma), tolerance)
+        self.assertLess(abs(true_omega - omega), tolerance)
+
+    def retry_test_across_graph_sizes(self, test_fn, sizes=[50, 100, 250, 500], retries_per_size=3):
+        """
+        Rerun randomized tests of asymptotic convergence across increasingly larger graph sizes until one succeeds.
+
+        This improves the performance of the test suite by automatically using smaller graphs for "easier" tests.
+        """
+        last_error = None
+        for n in sizes:
+            for _ in range(retries_per_size):
+                try:
+                    test_fn(n)
+                    return
+                except Exception as e:
+                    last_error = e
+                    if not isinstance(e, AssertionError):
+                        # test failed in unusual way (perhaps keyboard interrupt?), raising immediately
+                        raise e
+        raise last_error
 
     def test_temporal_SBM_correct_convergence_varying_copying_probabilty(self):
         for eta in [0.25, 0.5, 0.75, 0.9]:
-            membership = generate_random_partition(num_nodes=200, K=2)
-            self.assert_temporal_SBM_correct_convergence(copying_probability=eta, first_layer_membership=membership)
+            self.retry_test_across_graph_sizes(
+                test_fn=lambda n: self.assert_temporal_SBM_correct_convergence(
+                    copying_probability=eta,
+                    first_layer_membership=generate_random_partition(num_nodes=n, K=2)
+                )
+            )
 
     def test_temporal_SBM_correct_convergence_varying_p_in(self):
         for p_in in [0.5, 0.4, 0.3, 0.2]:
-            membership = generate_random_partition(num_nodes=100, K=2)
-            self.assert_temporal_SBM_correct_convergence(p_in=p_in, p_out=0.025, first_layer_membership=membership)
+            self.retry_test_across_graph_sizes(
+                test_fn=lambda n: self.assert_temporal_SBM_correct_convergence(
+                    p_in=p_in, p_out=0.025,
+                    first_layer_membership=generate_random_partition(num_nodes=n, K=2)
+                )
+            )
 
     def test_temporal_SBM_correct_convergence_varying_p_out(self):
         for p_out in [0.05, 0.04, 0.03, 0.02]:
-            membership = generate_random_partition(num_nodes=100, K=2)
-            self.assert_temporal_SBM_correct_convergence(p_out=p_out, first_layer_membership=membership)
+            self.retry_test_across_graph_sizes(
+                test_fn=lambda n: self.assert_temporal_SBM_correct_convergence(
+                    p_out=p_out, first_layer_membership=generate_random_partition(num_nodes=n, K=2)
+                )
+            )
 
     def test_temporal_SBM_correct_convergence_varying_num_communities(self):
         for K in [2, 3, 4, 5]:
-            membership = generate_random_partition(num_nodes=500, K=K)
-            self.assert_temporal_SBM_correct_convergence(first_layer_membership=membership)
+            self.retry_test_across_graph_sizes(
+                test_fn=lambda n: self.assert_temporal_SBM_correct_convergence(
+                    first_layer_membership=generate_random_partition(num_nodes=n, K=K)
+                )
+            )
 
     def test_temporal_SBM_correct_convergence_varying_num_layers(self):
         for num_layers in [20, 30, 40]:
-            membership = generate_random_partition(num_nodes=100, K=2)
-            self.assert_temporal_SBM_correct_convergence(first_layer_membership=membership, num_layers=num_layers)
+            self.retry_test_across_graph_sizes(
+                test_fn=lambda n: self.assert_temporal_SBM_correct_convergence(
+                    num_layers=num_layers,
+                    first_layer_membership=generate_random_partition(num_nodes=n, K=2)
+                )
+            )
 
     def test_directed_consistency_temporal_SBM_leiden(self):
         """Test parameter estimate consistency on a temporal SBM when the intralayer edges are directed."""

modularitypruning-1.4.1/setup.py

@@ -1,39 +0,0 @@
-import os
-
-from setuptools import setup
-
-here = os.path.abspath(os.path.dirname(__file__))
-
-# Get the long description from the README file
-with open(os.path.join(here, 'README.md'), encoding='utf-8') as f:
-    long_description = f.read()
-
-setup(
-    name='modularitypruning',
-    version='1.4.1',
-    package_dir={'modularitypruning': 'utilities'},
-    packages=['modularitypruning'],
-    url='https://github.com/ragibson/ModularityPruning',
-    license='',
-    author='Ryan Gibson',
-    author_email='ryan.alex.gibson@gmail.com',
-    description='Pruning tool to identify small subsets of network partitions that are '
-                'significant from the perspective of stochastic block model inference.',
-    long_description=long_description,
-    long_description_content_type='text/markdown',
-    classifiers=[
-        'Development Status :: 5 - Production/Stable',
-        'Topic :: Scientific/Engineering :: Information Analysis',
-        'Programming Language :: Python :: 3',
-        'Programming Language :: Python :: 3.8',
-        'Programming Language :: Python :: 3.9',
-        'Programming Language :: Python :: 3.10',
-        'Programming Language :: Python :: 3.11',
-        'Programming Language :: Python :: 3.12',
-        'Programming Language :: Python :: 3 :: Only',
-        'License :: OSI Approved :: MIT License'
-    ],
-    python_requires='>=3.8, <4',
-    install_requires=['leidenalg', 'matplotlib', "numpy", 'psutil', 'igraph',
-                      "scikit-learn", "scipy>=1.7", 'seaborn', 'tqdm']
-)