Engines Modularized

CHANGELOG.md

@@ -6,14 +6,17 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 
 ## [Unreleased]
 ### Added
+- `pyrgg.engines` package
+- `pyrgg.engines.pyrgg` module
+- `pyrgg.engines.erdos_reyni_gilbert` module
 - `Erdős-Rényi-Gilbert` generation model
-- `pyrgg_gen_using` function
 - Generation engine menu
 - `handle_string` function
 - `handle_pos_int` function
 - `handle_output_format` function
 - `handle_engine` function
 ### Changed
+- Tests separated in files for engines
 - `README.md` modified
 - `Python 3.12` added to `test.yml`
 - Menu options bug fixed

otherfile/pyrgg_profile.py

@@ -2,20 +2,24 @@
 """Profile file."""
 from pyrgg import *
 import pyrgg.params
+import pyrgg.engines.pyrgg as pyrgg_engine
 import random
 
-pyrgg.params.PYRGG_TEST_MODE = True
+os.environ["PYRGG_TEST_MODE"] = "1"
 random.seed(400)
 
-pyrgg_gen_using(
+pyrgg_engine.gen_using(
     dimacs_maker,
-    file_name='profile',
-    min_weight=1,
-    max_weight=5000,
-    vertices_number=10000,
-    min_edge=5,
-    max_edge=600,
-    sign=0,
-    direct=1,
-    self_loop=1,
-    multigraph=1)
+    'profile',
+    {
+        'min_weight':1,
+        'max_weight':5000,
+        'vertices':10000,
+        'min_edge':5,
+        'max_edge':600,
+        'sign':0,
+        'direct':1,
+        'self_loop':1,
+        'multigraph':1,
+    }
+    )

pyrgg/__init__.py

@@ -3,4 +3,5 @@
 from .functions import *
 from .graph_gen import *
 from .params import *
+from .engines import *
 __version__ = PYRGG_VERSION

pyrgg/__main__.py

@@ -8,6 +8,8 @@
 import argparse
 import doctest
 from art import tprint
+import pyrgg.engines.pyrgg as pyrgg_engine
+import pyrgg.engines.erdos_reyni_gilbert as erg_engine
 
 GENERATOR_MENU = {
     1: dimacs_maker,
@@ -28,9 +30,9 @@
     16: dot_maker,
 }
 
-ENGINE_GENERATOR = {
-    1: pyrgg_gen_using,
-    2: erdos_renyi_gilbert_gen_using,
+ENGINE_MAPPER = {
+    1: pyrgg_engine,
+    2: erg_engine,
 }
 
 
@@ -45,31 +47,12 @@ def gen_graph(input_dict, file_name):
     :return: None
     """
     first_time = time.perf_counter()
-    min_weight = input_dict["min_weight"]
-    max_weight = input_dict["max_weight"]
-    vertices_number = input_dict["vertices"]
-    min_edge = input_dict["min_edge"]
-    max_edge = input_dict["max_edge"]
-    sign = input_dict["sign"]
-    direct = input_dict["direct"]
-    self_loop = input_dict["self_loop"]
-    multigraph = input_dict["multigraph"]
     output_format = input_dict["output_format"]
-    probability = input_dict["probability"]
     engine = input_dict["engine"]
-    edge_number = ENGINE_GENERATOR[engine](
+    input_dict["edge_number"] = ENGINE_MAPPER[engine].gen_using(
         GENERATOR_MENU[output_format],
-        file_name=file_name,
-        min_weight=min_weight,
-        max_weight=max_weight,
-        vertices_number=vertices_number,
-        min_edge=min_edge,
-        max_edge=max_edge,
-        sign=sign,
-        direct=direct,
-        self_loop=self_loop,
-        multigraph=multigraph,
-        probability=probability)
+        file_name,
+        input_dict)
     if output_format == 4:
         json_to_yaml(file_name)
     if output_format == 7:
@@ -78,23 +61,15 @@ def gen_graph(input_dict, file_name):
     second_time = time.perf_counter()
     elapsed_time = second_time - first_time
     elapsed_time_format = time_convert(elapsed_time)
-    print("Total Number of Edges : " + str(edge_number))
+    print("Total Number of Edges : " + str(input_dict["edge_number"]))
     print("Graph Generated in " + elapsed_time_format)
     print("Where --> " + SOURCE_DIR)
-    logger(
-        file_name + SUFFIX_MENU[output_format],
-        vertices_number,
-        edge_number,
-        max_edge,
-        min_edge,
-        direct,
-        sign,
-        multigraph,
-        self_loop,
-        max_weight,
-        min_weight,
-        engine,
-        elapsed_time_format)
+    with open("logfile.log", "a") as file:
+        ENGINE_MAPPER[engine].logger(file,
+                                     file_name + SUFFIX_MENU[output_format],
+                                     elapsed_time_format,
+                                     input_dict)
+
 
 
 def run(input_dict=None):

pyrgg/engines/__init__.py

@@ -0,0 +1,4 @@
+# -*- coding: utf-8 -*-
+"""Engines module."""
+from .pyrgg import *
+from .erdos_reyni_gilbert import *

pyrgg/engines/erdos_reyni_gilbert.py

@@ -0,0 +1,103 @@
+# -*- coding: utf-8 -*-
+"""Erdős-Rényi-Gilbert Engine module."""
+import datetime
+from random import random
+from pyrgg.params import ENGINE_MENU, PYRGG_LOGGER_ERROR_MESSAGE
+
+LOGGER_TEMPLATE = """{0}
+Filename : {1}
+Probability : {2}
+Vertices : {3}
+Total Edges : {4}
+Engine : {5} ({6})
+Elapsed Time : {7}
+-------------------------------
+"""
+
+
+def edge_gen(n, p):
+    """
+    Generate each vertex connection number.
+
+    :param n: number of vertices
+    :type n: int
+    :param p: probability
+    :type p: float
+    :return: list of dicts
+    """
+    edge_dic = {}
+    edge_number = 0
+    for i in range(1, n + 1):
+        edge_dic[i] = []
+        for j in range(i + 1, n + 1):
+            if random() < p:
+                edge_dic[i].append(j)
+                edge_number += 1
+    return [edge_dic, edge_number]
+
+
+def gen_using(
+        gen_function,
+        file_name,
+        input_dict):
+    """
+    Generate graph using given function based on Erdos Renyi Gilbert model.
+
+    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_dic, edge_number = edge_gen(
+        input_dict['vertices'],
+        input_dict['probability'])
+    weight_dic = {key: [1] * edge_number for key in range(1, input_dict['vertices'] + 1)}
+    gen_function(
+        edge_dic,
+        weight_dic,
+        {
+            "file_name": file_name,
+            "vertices_number": input_dict['vertices'],
+            "max_weight": 1,
+            "min_weight": 1,
+            "min_edge": edge_number,
+            "max_edge": edge_number,
+            "sign": False,
+            "direct": False,
+            "self_loop": False,
+            "multigraph": False,
+            "edge_number": edge_number,
+        })
+    return edge_number
+
+
+def logger(file, file_name, elapsed_time, input_dict):
+    """
+    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:
+        file.write(LOGGER_TEMPLATE.format(datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
+                                          file_name,
+                                          str(input_dict["probability"]),
+                                          str(input_dict["vertices"]),
+                                          str(input_dict["edge_number"]),
+                                          input_dict["engine"],
+                                          ENGINE_MENU[input_dict["engine"]],
+                                          elapsed_time))
+    except Exception:
+        print(PYRGG_LOGGER_ERROR_MESSAGE)