Type Hint

CHANGELOG.md

@@ -5,6 +5,8 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
 and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
+### Changed
+- Python typing features added to all modules
 ## [1.9] - 2025-10-28
 ### Added
 - `pyrgg.engines.watts_strogatz` module

otherfile/version_check.py

@@ -56,13 +56,11 @@
 TEST_NUMBER = len(FILES.keys()) + 1
 
 
-def print_result(failed=False):
+def print_result(failed: bool = False) -> None:
     """
     Print final result.
 
     :param failed: failed flag
-    :type failed: bool
-    :return: None
     """
     message = "Version tag tests "
     if not failed:

pyrgg/__main__.py

@@ -1,5 +1,6 @@
 # -*- coding: utf-8 -*-
 """PyRGG main."""
+from typing import Dict, Any, Optional
 from pyrgg.graph_gen import *
 from pyrgg.functions import *
 from pyrgg.params import *
@@ -44,15 +45,12 @@
 }
 
 
-def gen_graph(input_dict, file_name):
+def gen_graph(input_dict: Dict[str, Any], file_name: str) -> None:
     """
     Generate a single graph.
 
     :param input_dict: input data
-    :type input_dict: dict
     :param file_name: file name
-    :type file_name: str
-    :return: None
     """
     first_time = time.perf_counter()
     output_format = input_dict["output_format"]
@@ -79,13 +77,11 @@ def gen_graph(input_dict, file_name):
                                      input_dict)
 
 
-def run(input_dict=None):
+def run(input_dict: Optional[Dict[str, Any]] = None) -> None:
     """
     Run proper converter.
 
     :param input_dict: input data
-    :type input_dict: dict
-    :return: None
     """
     if input_dict is None:
         input_dict = get_input()
@@ -103,12 +99,8 @@ def run(input_dict=None):
         print_line(40)
 
 
-def main():
-    """
-    CLI main function.
-
-    :return: None
-    """
+def main() -> None:
+    """CLI main function."""
     parser = argparse.ArgumentParser()
     parser.add_argument('--version', help='version', nargs="?", const=1)
     parser.add_argument('--config', help='config')

pyrgg/engines/barabasi_albert.py

@@ -1,19 +1,17 @@
 # -*- coding: utf-8 -*-
 """Barabási-Albert Engine module."""
+from typing import List, Dict, Callable, Any, IO, Tuple
 from random import sample
 from pyrgg.params import ENGINE_MENU, PYRGG_LOGGER_ERROR_MESSAGE
 from pyrgg.functions import save_log
 
 
-def edge_gen(n, k):
+def edge_gen(n: int, k: int) -> Tuple[Dict[int, List[int]], Dict[int, List[float]], int]:
     """
     Generate each vertex connection number.
 
     :param n: number of vertices
-    :type n: int
     :param k: number of edges to attach to a new node in each iteration, m in the Barabási-Albert model
-    :type k: int
-    :return: list of dicts
     """
     # We assume m0 is the same as k, similar to the original paper examples
     edge_dict = {i: [] for i in range(1, k + 1)}
@@ -33,22 +31,18 @@ def edge_gen(n, k):
 
 
 def gen_using(
-        gen_function,
-        file_name,
-        input_dict):
+        gen_function: Callable,
+        file_name: str,
+        input_dict: Dict[str, Any]) -> int:
     """
-    Generate graph using given function based on Barabási-Albert model.
+    Generate graph using given function based on Barabási-Albert model and return number of edges.
 
     Refer to (https://en.wikipedia.org/wiki/Barab%C3%A1si%E2%80%93Albert_model).
     We assume that m0 is the same as k and k is the number of edges to attach to a new node.
 
     :param gen_function: generation function
-    :type gen_function: function object
     :param file_name: file name
-    :type file_name: str
     :param input_dict: input data
-    :type input_dict: dict
-    :return: number of edges as int
     """
     edge_dict, weight_dict, edge_number = edge_gen(
         input_dict['vertices'],
@@ -69,19 +63,14 @@ def gen_using(
     return edge_number
 
 
-def logger(file, file_name, elapsed_time, input_dict):
+def logger(file: IO, file_name: str, elapsed_time: str, input_dict: Dict[str, Any]) -> None:
     """
     Save generated graph logs for Barabási-Albert engine.
 
     :param file: file to write log into
-    :type file: file object
     :param file_name: file name
-    :type file_name: str
     :param elapsed_time: elapsed time
-    :type elapsed_time: str
     :param input_dict: input data
-    :type input_dict: dict
-    :return: None
     """
     try:
         text = "Vertices : {vertices}\n".format(vertices=input_dict['vertices'])

pyrgg/engines/erdos_reyni.py

@@ -1,21 +1,18 @@
 # -*- coding: utf-8 -*-
 """Erdős-Rényi Engine module."""
+from typing import List, Dict, Callable, Any, IO, Tuple
 from random import shuffle
 from pyrgg.params import ENGINE_MENU, PYRGG_LOGGER_ERROR_MESSAGE
 from pyrgg.functions import save_log
 
 
-def edge_gen(n, m, direct):
+def edge_gen(n: int, m: int, direct: bool) -> Tuple[Dict[int, List[int]], Dict[int, List[float]], int]:
     """
     Generate each vertex connection number.
 
     :param n: number of vertices
-    :type n: int
     :param m: number of edges
-    :type m: int
     :param direct: directed graph flag
-    :type direct: bool
-    :return: list of dicts
     """
     edge_dict = {}
     weight_list = []
@@ -41,21 +38,17 @@ def edge_gen(n, m, direct):
 
 
 def gen_using(
-        gen_function,
-        file_name,
-        input_dict):
+        gen_function: Callable,
+        file_name: str,
+        input_dict: Dict[str, Any]) -> int:
     """
-    Generate graph using given function based on Erdos Renyi - G(n, m) model.
+    Generate graph using given function based on Erdos Renyi - G(n, m) model and return the number of edges.
 
     Refer to (https://en.wikipedia.org/wiki/Erd%C5%91s%E2%80%93R%C3%A9nyi_model).
 
     :param gen_function: generation function
-    :type gen_function: function object
     :param file_name: file name
-    :type file_name: str
     :param input_dict: input data
-    :type input_dict: dict
-    :return: number of edges as int
     """
     edge_dict, weight_dict, edge_number = edge_gen(
         input_dict['vertices'],
@@ -77,19 +70,14 @@ def gen_using(
     return edge_number
 
 
-def logger(file, file_name, elapsed_time, input_dict):
+def logger(file: IO, file_name: str, elapsed_time: str, input_dict: Dict[str, Any]) -> None:
     """
     Save generated graph logs for Erdős-Rényi engine.
 
     :param file: file to write log into
-    :type file: file object
     :param file_name: file name
-    :type file_name: str
     :param elapsed_time: elapsed time
-    :type elapsed_time: str
     :param input_dict: input data
-    :type input_dict: dict
-    :return: None
     """
     try:
         text = "Vertices : {vertices}\n".format(vertices=input_dict['vertices'])

pyrgg/engines/erdos_reyni_gilbert.py

@@ -1,21 +1,18 @@
 # -*- coding: utf-8 -*-
 """Erdős-Rényi-Gilbert Engine module."""
+from typing import List, Dict, Callable, Any, IO, Tuple
 from random import random
 from pyrgg.params import ENGINE_MENU, PYRGG_LOGGER_ERROR_MESSAGE
 from pyrgg.functions import save_log
 
 
-def edge_gen(n, p, direct):
+def edge_gen(n: int, p: float, direct: bool) -> Tuple[Dict[int, List[int]], Dict[int, List[float]], int]:
     """
     Generate each vertex connection number.
 
     :param n: number of vertices
-    :type n: int
     :param p: probability
-    :type p: float
     :param direct: directed graph flag
-    :type direct: bool
-    :return: list of dicts
     """
     edge_dict = {}
     edge_number = 0
@@ -36,21 +33,17 @@ def edge_gen(n, p, direct):
 
 
 def gen_using(
-        gen_function,
-        file_name,
-        input_dict):
+        gen_function: Callable,
+        file_name: str,
+        input_dict: Dict[str, Any]) -> int:
     """
-    Generate graph using given function based on Erdos Renyi Gilbert - G(n, p) model.
+    Generate graph using given function based on Erdos Renyi Gilbert - G(n, p) model and return the number of edges.
 
     Refer to (https://en.wikipedia.org/wiki/Erd%C5%91s%E2%80%93R%C3%A9nyi_model).
 
     :param gen_function: generation function
-    :type gen_function: function object
     :param file_name: file name
-    :type file_name: str
     :param input_dict: input data
-    :type input_dict: dict
-    :return: number of edges as int
     """
     edge_dict, weight_dict, edge_number = edge_gen(
         input_dict['vertices'],
@@ -72,19 +65,14 @@ def gen_using(
     return edge_number
 
 
-def logger(file, file_name, elapsed_time, input_dict):
+def logger(file: IO, file_name: str, elapsed_time: str, input_dict: Dict[str, Any]) -> None:
     """
     Save generated graph logs for Erdős-Rényi-Gilbert engine.
 
     :param file: file to write log into
-    :type file: file object
     :param file_name: file name
-    :type file_name: str
     :param elapsed_time: elapsed time
-    :type elapsed_time: str
     :param input_dict: input data
-    :type input_dict: dict
-    :return: None
     """
     try:
         text = "Vertices : {vertices}\n".format(vertices=input_dict['vertices'])