risk-network 0.0.7b8__py3-none-any.whl → 0.0.7b10__py3-none-any.whl

risk/__init__.py

@@ -7,4 +7,4 @@ RISK: RISK Infers Spatial Kinships
 
 from risk.risk import RISK
 
-__version__ = "0.0.7-beta.8"
+__version__ = "0.0.7-beta.10"

risk/annotations/annotations.py

@@ -177,19 +177,18 @@ def get_description(words_column: pd.Series) -> str:
     all_words = words_column.str.cat(sep=" ")
     tokens = word_tokenize(all_words)
 
-    # Check if all tokens are numeric strings or contain a mixture of strings and numbers
+    # Separate numeric tokens
     numeric_tokens = [token for token in tokens if token.replace(".", "", 1).isdigit()]
-    non_numeric_tokens = [token for token in tokens if not token.replace(".", "", 1).isdigit()]
     # If there's only one unique numeric value, return it directly as a string
     unique_numeric_values = set(numeric_tokens)
     if len(unique_numeric_values) == 1:
         return f"{list(unique_numeric_values)[0]}"
 
-    # Allow the inclusion of both alphabetic and numeric tokens if mixture is detected
+    # Ensure that all values in 'words' are strings and include both alphabetic and numeric tokens
     words = [
-        (
+        str(
             word.lower() if word.istitle() else word
-        )  # Lowercase all words except proper nouns (e.g., RNA, mRNA)
+        )  # Convert to string and lowercase all words except proper nouns (e.g., RNA, mRNA)
         for word in tokens
         if word.isalpha()
         or word.replace(".", "", 1).isdigit()  # Keep alphabetic words and numeric strings
@@ -263,11 +262,11 @@ def _generate_coherent_description(words: List[str]) -> str:
     Returns:
         str: A coherent description formed by arranging the words in a logical sequence.
     """
-    # If there are no words or the input is invalid, raise an error
-    if not words or not isinstance(words, list) or not all(isinstance(word, str) for word in words):
-        raise ValueError("Input must be a list of strings.")
+    # If there are no words, return a keyword indicating no data is available
+    if not words:
+        return "N/A"
 
-    # If there's only one unique word, return it directly (even if it's a number-like string)
+    # If there's only one unique word, return it directly
     unique_words = set(words)
     if len(unique_words) == 1:
         return list(unique_words)[0]

risk/annotations/io.py

@@ -12,7 +12,7 @@ import networkx as nx
 import pandas as pd
 
 from risk.annotations.annotations import load_annotations
-from risk.log import params, print_header
+from risk.log import params, logger, log_header
 
 
 class AnnotationsIO:
@@ -218,7 +218,7 @@ def _log_loading(filetype: str, filepath: str = "") -> None:
         filetype (str): The type of the file being loaded (e.g., 'Cytoscape').
         filepath (str, optional): The path to the file being loaded.
     """
-    print_header("Loading annotations")
-    print(f"Filetype: {filetype}")
+    log_header("Loading annotations")
+    logger.debug(f"Filetype: {filetype}")
     if filepath:
-        print(f"Filepath: {filepath}")
+        logger.debug(f"Filepath: {filepath}")

risk/log/__init__.py

@@ -3,7 +3,7 @@ risk/log
 ~~~~~~~~
 """
 
-from .console import print_header
+from .config import logger, log_header, set_global_verbosity
 from .params import Params
 
 params = Params()

risk/log/config.py

@@ -0,0 +1,49 @@
+"""
+risk/log/config
+~~~~~~~~~~~~~~~
+"""
+
+import logging
+
+# Create a global logger
+logger = logging.getLogger("risk_logger")
+logger.setLevel(logging.DEBUG)  # Start with the highest level; adjust as needed
+# Create a console handler
+console_handler = logging.StreamHandler()
+console_handler.setLevel(logging.DEBUG)  # Set the handler level (can be controlled later)
+# Create a formatter and set it for the handler
+formatter = logging.Formatter("%(message)s")
+console_handler.setFormatter(formatter)
+
+# Add the handler to the logger if it doesn't already exist
+if not logger.hasHandlers():
+    logger.addHandler(console_handler)
+
+
+def set_global_verbosity(verbose):
+    """Set the global verbosity level for the logger.
+
+    Args:
+        verbose (bool): Whether to display all log messages (True) or only error messages (False).
+
+    Returns:
+        None
+    """
+    if verbose:
+        logger.setLevel(logging.DEBUG)  # Show all messages
+        console_handler.setLevel(logging.DEBUG)
+    else:
+        logger.setLevel(logging.ERROR)  # Show only error messages
+        console_handler.setLevel(logging.ERROR)
+
+
+def log_header(input_string: str) -> None:
+    """Log the input string as a header with a line of dashes above and below it.
+
+    Args:
+        input_string (str): The string to be printed as a header.
+    """
+    border = "-" * len(input_string)
+    logger.info(border)
+    logger.info(input_string)
+    logger.info(border)

risk/log/params.py

@@ -12,7 +12,7 @@ from typing import Any, Dict
 
 import numpy as np
 
-from .console import print_header
+from .config import logger, log_header
 
 # Suppress all warnings - this is to resolve warnings from multiprocessing
 warnings.filterwarnings("ignore")
@@ -35,11 +35,11 @@ def _safe_param_export(func):
             filepath = (
                 kwargs.get("filepath") or args[1]
             )  # Assuming filepath is always the second argument
-            print(f"Parameters successfully exported to filepath: {filepath}")
+            logger.info(f"Parameters successfully exported to filepath: {filepath}")
             return result
         except Exception as e:
             filepath = kwargs.get("filepath") or args[1]
-            print(f"An error occurred while exporting parameters to {filepath}: {e}")
+            logger.error(f"An error occurred while exporting parameters to {filepath}: {e}")
             return None
 
     return wrapper
@@ -161,7 +161,7 @@ class Params:
         Returns:
             dict: A dictionary containing the processed parameters.
         """
-        print_header("Loading parameters")
+        log_header("Loading parameters")
         return _convert_ndarray_to_list(
             {
                 "annotations": self.annotations,

risk/neighborhoods/domains.py

@@ -15,6 +15,7 @@ from sklearn.metrics import silhouette_score
 
 from risk.annotations import get_description
 from risk.constants import GROUP_LINKAGE_METHODS, GROUP_DISTANCE_METRICS
+from risk.log import logger
 
 
 def define_domains(
@@ -45,10 +46,10 @@ def define_domains(
         )
         # Perform hierarchical clustering
         Z = linkage(m, method=best_linkage, metric=best_metric)
-        print(
+        logger.debug(
             f"Linkage criterion: '{linkage_criterion}'\nLinkage method: '{best_linkage}'\nLinkage metric: '{best_metric}'"
         )
-        print(f"Optimal linkage threshold: {round(best_threshold, 3)}")
+        logger.debug(f"Optimal linkage threshold: {round(best_threshold, 3)}")
         # Calculate the optimal threshold for clustering
         max_d_optimal = np.max(Z[:, 2]) * best_threshold
         # Assign domains to the annotations matrix
@@ -58,7 +59,9 @@ def define_domains(
     except ValueError:
         # If a ValueError is encountered, handle it by assigning unique domains
         n_rows = len(top_annotations)
-        print(f"Error encountered. Skipping clustering and assigning {n_rows} unique domains.")
+        logger.error(
+            f"Error encountered. Skipping clustering and assigning {n_rows} unique domains."
+        )
         top_annotations["domain"] = range(1, n_rows + 1)  # Assign unique domains
 
     # Create DataFrames to store domain information

risk/neighborhoods/neighborhoods.py

@@ -20,6 +20,7 @@ from risk.neighborhoods.community import (
     calculate_spinglass_neighborhoods,
     calculate_walktrap_neighborhoods,
 )
+from risk.log import logger
 
 # Suppress DataConversionWarning
 warnings.filterwarnings(action="ignore", category=DataConversionWarning)
@@ -129,7 +130,7 @@ def process_neighborhoods(
     enrichment_matrix = neighborhoods["enrichment_matrix"]
     binary_enrichment_matrix = neighborhoods["binary_enrichment_matrix"]
     significant_enrichment_matrix = neighborhoods["significant_enrichment_matrix"]
-    print(f"Imputation depth: {impute_depth}")
+    logger.debug(f"Imputation depth: {impute_depth}")
     if impute_depth:
         (
             enrichment_matrix,
@@ -142,7 +143,7 @@ def process_neighborhoods(
             max_depth=impute_depth,
         )
 
-    print(f"Pruning threshold: {prune_threshold}")
+    logger.debug(f"Pruning threshold: {prune_threshold}")
     if prune_threshold:
         (
             enrichment_matrix,

risk/network/io.py

@@ -16,7 +16,7 @@ import networkx as nx
 import pandas as pd
 
 from risk.network.geometry import assign_edge_lengths
-from risk.log import params, print_header
+from risk.log import params, logger, log_header
 
 
 class NetworkIO:
@@ -57,9 +57,8 @@ class NetworkIO:
             weight_label=weight_label,
         )
 
-    @classmethod
+    @staticmethod
     def load_gpickle_network(
-        cls,
         filepath: str,
         compute_sphere: bool = True,
         surface_depth: float = 0.0,
@@ -80,7 +79,7 @@ class NetworkIO:
         Returns:
             nx.Graph: Loaded and processed network.
         """
-        networkio = cls(
+        networkio = NetworkIO(
             compute_sphere=compute_sphere,
             surface_depth=surface_depth,
             min_edges_per_node=min_edges_per_node,
@@ -109,9 +108,8 @@ class NetworkIO:
         # Initialize the graph
         return self._initialize_graph(G)
 
-    @classmethod
+    @staticmethod
     def load_networkx_network(
-        cls,
         network: nx.Graph,
         compute_sphere: bool = True,
         surface_depth: float = 0.0,
@@ -132,7 +130,7 @@ class NetworkIO:
         Returns:
             nx.Graph: Loaded and processed network.
         """
-        networkio = cls(
+        networkio = NetworkIO(
             compute_sphere=compute_sphere,
             surface_depth=surface_depth,
             min_edges_per_node=min_edges_per_node,
@@ -158,9 +156,8 @@ class NetworkIO:
         # Initialize the graph
         return self._initialize_graph(network)
 
-    @classmethod
+    @staticmethod
     def load_cytoscape_network(
-        cls,
         filepath: str,
         source_label: str = "source",
         target_label: str = "target",
@@ -187,7 +184,7 @@ class NetworkIO:
         Returns:
             nx.Graph: Loaded and processed network.
         """
-        networkio = cls(
+        networkio = NetworkIO(
             compute_sphere=compute_sphere,
             surface_depth=surface_depth,
             min_edges_per_node=min_edges_per_node,
@@ -312,9 +309,8 @@ class NetworkIO:
             if os.path.exists(tmp_dir):
                 shutil.rmtree(tmp_dir)
 
-    @classmethod
+    @staticmethod
     def load_cytoscape_json_network(
-        cls,
         filepath: str,
         source_label: str = "source",
         target_label: str = "target",
@@ -339,7 +335,7 @@ class NetworkIO:
         Returns:
             NetworkX graph: Loaded and processed network.
         """
-        networkio = cls(
+        networkio = NetworkIO(
             compute_sphere=compute_sphere,
             surface_depth=surface_depth,
             min_edges_per_node=min_edges_per_node,
@@ -455,10 +451,10 @@ class NetworkIO:
         # Log the number of nodes and edges before and after cleaning
         num_final_nodes = G.number_of_nodes()
         num_final_edges = G.number_of_edges()
-        print(f"Initial node count: {num_initial_nodes}")
-        print(f"Final node count: {num_final_nodes}")
-        print(f"Initial edge count: {num_initial_edges}")
-        print(f"Final edge count: {num_final_edges}")
+        logger.debug(f"Initial node count: {num_initial_nodes}")
+        logger.debug(f"Final node count: {num_final_nodes}")
+        logger.debug(f"Initial edge count: {num_initial_edges}")
+        logger.debug(f"Final edge count: {num_final_edges}")
 
     def _assign_edge_weights(self, G: nx.Graph) -> None:
         """Assign weights to the edges in the graph.
@@ -476,7 +472,7 @@ class NetworkIO:
             )  # Default to 1.0 if 'weight' not present
 
         if self.include_edge_weight and missing_weights:
-            print(f"Total edges missing weights: {missing_weights}")
+            logger.debug(f"Total edges missing weights: {missing_weights}")
 
     def _validate_nodes(self, G: nx.Graph) -> None:
         """Validate the graph structure and attributes.
@@ -514,14 +510,14 @@ class NetworkIO:
             filetype (str): The type of the file being loaded (e.g., 'CSV', 'JSON').
             filepath (str, optional): The path to the file being loaded. Defaults to "".
         """
-        print_header("Loading network")
-        print(f"Filetype: {filetype}")
+        log_header("Loading network")
+        logger.debug(f"Filetype: {filetype}")
         if filepath:
-            print(f"Filepath: {filepath}")
-        print(f"Edge weight: {'Included' if self.include_edge_weight else 'Excluded'}")
+            logger.debug(f"Filepath: {filepath}")
+        logger.debug(f"Edge weight: {'Included' if self.include_edge_weight else 'Excluded'}")
         if self.include_edge_weight:
-            print(f"Weight label: {self.weight_label}")
-        print(f"Minimum edges per node: {self.min_edges_per_node}")
-        print(f"Projection: {'Sphere' if self.compute_sphere else 'Plane'}")
+            logger.debug(f"Weight label: {self.weight_label}")
+        logger.debug(f"Minimum edges per node: {self.min_edges_per_node}")
+        logger.debug(f"Projection: {'Sphere' if self.compute_sphere else 'Plane'}")
         if self.compute_sphere:
-            print(f"Surface depth: {self.surface_depth}")
+            logger.debug(f"Surface depth: {self.surface_depth}")

risk/risk.py

@@ -10,7 +10,7 @@ import numpy as np
 import pandas as pd
 
 from risk.annotations import AnnotationsIO, define_top_annotations
-from risk.log import params, print_header
+from risk.log import params, logger, log_header, set_global_verbosity
 from risk.neighborhoods import (
     define_domains,
     get_network_neighborhoods,
@@ -33,16 +33,32 @@ class RISK(NetworkIO, AnnotationsIO):
     and performing network-based statistical analysis, such as neighborhood significance testing.
     """
 
-    def __init__(self, *args, **kwargs):
-        """Initialize the RISK class with configuration settings."""
+    def __init__(self, *args, verbose: bool = True, **kwargs):
+        """Initialize the RISK class with configuration settings.
+
+        Args:
+            verbose (bool): If False, suppresses all log messages to the console. Defaults to True.
+            *args: Variable length argument list.
+            **kwargs: Arbitrary keyword arguments.
+
+        Note:
+            - All *args and **kwargs are passed to NetworkIO's __init__ method.
+            - AnnotationsIO does not take any arguments and is initialized without them.
+        """
+        # Set global verbosity for logging
+        set_global_verbosity(verbose)
         # Initialize and log network parameters
         params.initialize()
-        # Initialize the parent classes
+        # Use super() to call NetworkIO's __init__ with the given arguments and keyword arguments
         super().__init__(*args, **kwargs)
 
     @property
-    def params(self):
-        """Access the logged parameters."""
+    def params(self) -> params:
+        """Access the logged network parameters.
+
+        Returns:
+            Params: An instance of the Params class with logged parameters and methods to access or update them.
+        """
         return params
 
     def load_neighborhoods_by_hypergeom(
@@ -69,7 +85,7 @@ class RISK(NetworkIO, AnnotationsIO):
         Returns:
             dict: Computed significance of neighborhoods.
         """
-        print_header("Running hypergeometric test")
+        log_header("Running hypergeometric test")
         # Log neighborhood analysis parameters
         params.log_neighborhoods(
             distance_metric=distance_metric,
@@ -122,7 +138,7 @@ class RISK(NetworkIO, AnnotationsIO):
         Returns:
             dict: Computed significance of neighborhoods.
         """
-        print_header("Running Poisson test")
+        log_header("Running Poisson test")
         # Log neighborhood analysis parameters
         params.log_neighborhoods(
             distance_metric=distance_metric,
@@ -181,7 +197,7 @@ class RISK(NetworkIO, AnnotationsIO):
         Returns:
             dict: Computed significance of neighborhoods.
         """
-        print_header("Running permutation test")
+        log_header("Running permutation test")
         # Log neighborhood analysis parameters
         params.log_neighborhoods(
             distance_metric=distance_metric,
@@ -205,10 +221,10 @@ class RISK(NetworkIO, AnnotationsIO):
         )
 
         # Log and display permutation test settings
-        print(f"Neighborhood scoring metric: '{score_metric}'")
-        print(f"Null distribution: '{null_distribution}'")
-        print(f"Number of permutations: {num_permutations}")
-        print(f"Maximum workers: {max_workers}")
+        logger.debug(f"Neighborhood scoring metric: '{score_metric}'")
+        logger.debug(f"Null distribution: '{null_distribution}'")
+        logger.debug(f"Number of permutations: {num_permutations}")
+        logger.debug(f"Maximum workers: {max_workers}")
         # Run permutation test to compute neighborhood significance
         neighborhood_significance = compute_permutation_test(
             neighborhoods=neighborhoods,
@@ -260,7 +276,7 @@ class RISK(NetworkIO, AnnotationsIO):
             NetworkGraph: A fully initialized and processed NetworkGraph object.
         """
         # Log the parameters and display headers
-        print_header("Finding significant neighborhoods")
+        log_header("Finding significant neighborhoods")
         params.log_graph(
             tail=tail,
             pval_cutoff=pval_cutoff,
@@ -274,9 +290,9 @@ class RISK(NetworkIO, AnnotationsIO):
             max_cluster_size=max_cluster_size,
         )
 
-        print(f"p-value cutoff: {pval_cutoff}")
-        print(f"FDR BH cutoff: {fdr_cutoff}")
-        print(
+        logger.debug(f"p-value cutoff: {pval_cutoff}")
+        logger.debug(f"FDR BH cutoff: {fdr_cutoff}")
+        logger.debug(
             f"Significance tail: '{tail}' ({'enrichment' if tail == 'right' else 'depletion' if tail == 'left' else 'both'})"
         )
         # Calculate significant neighborhoods based on the provided parameters
@@ -288,7 +304,7 @@ class RISK(NetworkIO, AnnotationsIO):
             fdr_cutoff=fdr_cutoff,
         )
 
-        print_header("Processing neighborhoods")
+        log_header("Processing neighborhoods")
         # Process neighborhoods by imputing and pruning based on the given settings
         processed_neighborhoods = process_neighborhoods(
             network=network,
@@ -297,9 +313,9 @@ class RISK(NetworkIO, AnnotationsIO):
             prune_threshold=prune_threshold,
         )
 
-        print_header("Finding top annotations")
-        print(f"Min cluster size: {min_cluster_size}")
-        print(f"Max cluster size: {max_cluster_size}")
+        log_header("Finding top annotations")
+        logger.debug(f"Min cluster size: {min_cluster_size}")
+        logger.debug(f"Max cluster size: {max_cluster_size}")
         # Define top annotations based on processed neighborhoods
         top_annotations = self._define_top_annotations(
             network=network,
@@ -309,7 +325,7 @@ class RISK(NetworkIO, AnnotationsIO):
             max_cluster_size=max_cluster_size,
         )
 
-        print_header("Optimizing distance threshold for domains")
+        log_header("Optimizing distance threshold for domains")
         # Define domains in the network using the specified clustering settings
         domains = self._define_domains(
             neighborhoods=processed_neighborhoods,
@@ -357,7 +373,7 @@ class RISK(NetworkIO, AnnotationsIO):
         Returns:
             NetworkPlotter: A NetworkPlotter object configured with the given parameters.
         """
-        print_header("Loading plotter")
+        log_header("Loading plotter")
         # Log the plotter settings
         params.log_plotter(
             figsize=figsize,
@@ -398,9 +414,9 @@ class RISK(NetworkIO, AnnotationsIO):
         else:
             for_print_distance_metric = distance_metric
         # Log and display neighborhood settings
-        print(f"Distance metric: '{for_print_distance_metric}'")
-        print(f"Edge length threshold: {edge_length_threshold}")
-        print(f"Random seed: {random_seed}")
+        logger.debug(f"Distance metric: '{for_print_distance_metric}'")
+        logger.debug(f"Edge length threshold: {edge_length_threshold}")
+        logger.debug(f"Random seed: {random_seed}")
 
         # Compute neighborhoods based on the network and distance metric
         neighborhoods = get_network_neighborhoods(

{risk_network-0.0.7b8.dist-info → risk_network-0.0.7b10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: risk-network
-Version: 0.0.7b8
+Version: 0.0.7b10
 Summary: A Python package for biological network analysis
 Author: Ira Horecka
 Author-email: Ira Horecka <ira89@icloud.com>

{risk_network-0.0.7b8.dist-info → risk_network-0.0.7b10.dist-info}/RECORD

@@ -1,20 +1,20 @@
-risk/__init__.py,sha256=kEtmAgswqdIS5KBKHJO1NZkxJRF6s4ww_cjSOrBuJ4A,112
+risk/__init__.py,sha256=cMQ9biQEb8gYBZtC-NebxpomJpoEQOMHT0jhH6N5dJc,113
 risk/constants.py,sha256=XInRaH78Slnw_sWgAsBFbUHkyA0h0jL0DKGuQNbOvjM,550
-risk/risk.py,sha256=6666BzdMTgOaQl98ZKiJ19c6XBot26eTJ0iIlk-ZCZQ,20515
+risk/risk.py,sha256=JlKkNrdM3LwMl1Wqs3KZDOhnOwGm9EzsquoJ1GBsU0g,21339
 risk/annotations/__init__.py,sha256=vUpVvMRE5if01Ic8QY6M2Ae3EFGJHdugEe9PdEkAW4Y,138
-risk/annotations/annotations.py,sha256=k9LGTL2uqdYvI5F3jU3UKz-O855B-DoazGPMzSn-XUc,11673
-risk/annotations/io.py,sha256=lo7NKqOVkeeBp58JBxWJHtA0xjL5Yoxqe9Ox0daKlZk,9457
-risk/log/__init__.py,sha256=xuLImfxFlKpnVhzi_gDYlr2_c9cLkrw2c_3iEsXb1as,107
-risk/log/console.py,sha256=im9DRExwf6wHlcn9fewoDcKIpo3vPcorZIaNAl-0csY,355
-risk/log/params.py,sha256=Rfdg5UcGCrG80m6V79FyORERWUqIzHFO7tGiY4zAImM,6347
+risk/annotations/annotations.py,sha256=3FFyJE9Gp5oRN72_8iVAUnecsmTtx2G2fp5AlCY1oUk,11405
+risk/annotations/io.py,sha256=om_3e26PQmrICY25UJnXuuZ20oXENNlr1QCBmOxYlMI,9475
+risk/log/__init__.py,sha256=aDUz5LMFQsz0UlsQI2EdXtiBKRLfml1UMeZKC7QQIGU,134
+risk/log/config.py,sha256=tYFQ75yyVUYB5WA040037dtOL1SDoDwyGVpkP2P1dZc,1439
+risk/log/params.py,sha256=DUmsqPo9hi3rQHFgLTunP14I-vVoyQSFZbx5aSYmVts,6363
 risk/neighborhoods/__init__.py,sha256=tKKEg4lsbqFukpgYlUGxU_v_9FOqK7V0uvM9T2QzoL0,206
 risk/neighborhoods/community.py,sha256=stYYBXeZlGLMV-k8ckQeIqThT6v9y-S3hETobAo9590,6817
-risk/neighborhoods/domains.py,sha256=vTCKtRE0oFcY862squrF7_cqCjnckiC9Sl0Qh2FM81k,10665
-risk/neighborhoods/neighborhoods.py,sha256=5WVXCZ0f-MzUfDITdNlL0NgDS3DBamdc_ZVPA-p9j7U,18218
+risk/neighborhoods/domains.py,sha256=X-qmnhb7K_CHCrRDBtpBizt8BmyJjKCzKZdh-NSUf_c,10736
+risk/neighborhoods/neighborhoods.py,sha256=M-wL4xB_BUTlSZg90swygO5NdrZ6hFUFqs6jsiZaqHk,18260
 risk/network/__init__.py,sha256=iEPeJdZfqp0toxtbElryB8jbz9_t_k4QQ3iDvKE8C_0,126
 risk/network/geometry.py,sha256=H1yGVVqgbfpzBzJwEheDLfvGLSA284jGQQTn612L4Vc,6759
 risk/network/graph.py,sha256=_LEoom4EEowGALuJKSXcev9RAAHu2FqIeq3u7mkifW0,16479
-risk/network/io.py,sha256=gG50kOknO-D3HkW1HsbHMkTMvjUtn3l4W4Jwd-rXNr8,21202
+risk/network/io.py,sha256=ASoKG4vkCC_aHwxlF4502W_SyaaCrRnHsTmRwL00spI,21266
 risk/network/plot.py,sha256=3OucCoKJwx9M9H4lqAvcQdM9YiCSyIxz21jyqDbpffc,62286
 risk/stats/__init__.py,sha256=WcgoETQ-hS0LQqKRsAMIPtP15xZ-4eul6VUBuUx4Wzc,220
 risk/stats/hypergeom.py,sha256=o6Qnj31gCAKxr2uQirXrbv7XvdDJGEq69MFW-ubx_hA,2272
@@ -23,8 +23,8 @@ risk/stats/stats.py,sha256=kvShov-94W6ffgDUTb522vB9hDJQSyTsYif_UIaFfSM,7059
 risk/stats/permutation/__init__.py,sha256=neJp7FENC-zg_CGOXqv-iIvz1r5XUKI9Ruxhmq7kDOI,105
 risk/stats/permutation/permutation.py,sha256=kmSZ7bQ-AD0TFiQDgIwfxTeqHa4pjp7fIcOzAqyhUNY,9714
 risk/stats/permutation/test_functions.py,sha256=HuDIM-V1jkkfE1rlaIqrWWBSKZt3dQ1f-YEDjWpnLSE,2343
-risk_network-0.0.7b8.dist-info/LICENSE,sha256=jOtLnuWt7d5Hsx6XXB2QxzrSe2sWWh3NgMfFRetluQM,35147
-risk_network-0.0.7b8.dist-info/METADATA,sha256=aFjqRdtk2rsHn0AHuofhj9ZtkFFuuxfgLd_DnyX52qA,43142
-risk_network-0.0.7b8.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
-risk_network-0.0.7b8.dist-info/top_level.txt,sha256=NX7C2PFKTvC1JhVKv14DFlFAIFnKc6Lpsu1ZfxvQwVw,5
-risk_network-0.0.7b8.dist-info/RECORD,,
+risk_network-0.0.7b10.dist-info/LICENSE,sha256=jOtLnuWt7d5Hsx6XXB2QxzrSe2sWWh3NgMfFRetluQM,35147
+risk_network-0.0.7b10.dist-info/METADATA,sha256=H_rRPorQwnrzeJ26vQph8anQHm0GPMjA_N3xro13oxs,43143
+risk_network-0.0.7b10.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
+risk_network-0.0.7b10.dist-info/top_level.txt,sha256=NX7C2PFKTvC1JhVKv14DFlFAIFnKc6Lpsu1ZfxvQwVw,5
+risk_network-0.0.7b10.dist-info/RECORD,,

risk/log/console.py

@@ -1,16 +0,0 @@
-"""
-risk/log/console
-~~~~~~~~~~~~~~~~
-"""
-
-
-def print_header(input_string: str) -> None:
-    """Print the input string as a header with a line of dashes above and below it.
-
-    Args:
-        input_string (str): The string to be printed as a header.
-    """
-    border = "-" * len(input_string)
-    print(border)
-    print(input_string)
-    print(border)