remove docstrings of private functions, change results.py functions to be private

Author: amzhao16

pygridsim/core.py

@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 from altdss import altdss
 from pygridsim.parameters import _make_load_node, _make_source_node, _make_generator, _make_pv
-from pygridsim.results import query_solution, export_results
+from pygridsim.results import _query_solution, _export_results
 from pygridsim.lines import _make_line
 
 """Main module."""
@@ -173,10 +173,10 @@ def results(self, queries: list[str], export_path = ""):
 		"""
 		results = {}
 		for query in queries:
-			results[query] = query_solution(query)
+			results[query] = _query_solution(query)
 
 		if (export_path):
-			export_results(results, export_path)
+			_export_results(results, export_path)
 
 		return results
 

pygridsim/lines.py

@@ -7,9 +7,6 @@
 from dss.enums import LineUnits
 
 def _get_kv(node_name):
-    """
-    Given a string of a node that exists, fetch its kV or raise error if doesn't exist
-    """
     if node_name == "source" and node_name in altdss.Vsource:
         return altdss.Vsource[node_name].BasekV
     elif "load" in node_name and node_name in altdss.Load:
@@ -20,16 +17,6 @@ def _get_kv(node_name):
         raise KeyError("Invalid src or dst name")
 
 def _make_line(src, dst, line_type, count, params = {}, transformer = True):
-    """
-    Add a line between src and dst
-
-    Args:
-        src: where line starts (node)
-        dst: where line end (node)
-        params (optional): any non-default parameters to use. Params can also include transformer params like XHL, Conns
-    Returns:
-        Line object that was created
-    """
     _check_valid_params(params, defaults.VALID_LINE_TRANSFORMER_PARAMS)
     line_type_obj = _get_enum_obj(LineType, line_type)
     line = altdss.Line.new('line' + str(count))

pygridsim/parameters.py

@@ -20,25 +20,13 @@ def _get_enum_obj(enum_class, enum_val):
     return enum_obj
 
 def _random_param(range):
-    """
-    Given the range of a normal parameter (i.e. normal load for a house), uniformly select value.
-    In case the value is not a range and just a value, just return that value
-
-    Args:
-        [lower_bound, upper_bound]; range of typical value
-    Return:
-        Randomly selected value in range
-    """
     if type(range) is not list:
         return range
 
     [max, min] = range
     return random.random() * (max - min) + min
 
 def _get_param(params, name, default):
-    """
-    Get param or use default
-    """
     if name in params:
         return params[name]
     else:
@@ -55,18 +43,6 @@ def _check_valid_params(params, valid_params):
             raise ValueError("KV cannot be less than 0")
 
 def _make_load_node(load_params, load_type, count):
-    """
-    Make a load node with the parmeters given, filling in with defaults for
-    any undefined but required parameter. Parse through the parameters, potentially throwing errors and warnings if
-    one of the parameter names is invalid.
-
-    Args:
-        load_params: any specified parameters to override default ones
-        load_type: LoadType representing type of load, house, commercial, industrial
-        count: how many loads have already been made, to not use repeat names
-    Return:
-        load object
-    """
     _check_valid_params(load_params, defaults.VALID_LOAD_PARAMS)
     load_type_obj = _get_enum_obj(LoadType, load_type)
 
@@ -81,16 +57,6 @@ def _make_load_node(load_params, load_type, count):
     return load
 
 def _make_source_node(source_params, source_type):
-    """
-    Make a source node with the parmeters given, filling in with defaults for
-    any undefined but required parameter. Parse through the parameters, potentially throwing errors and warnings if
-    one of the parameter names is invalid. Note that this updates the source node if one already exists
-
-    Args:
-        source_params: any specified parameters to override default ones
-    Return:
-        source object
-    """
     _check_valid_params(source_params, defaults.VALID_SOURCE_PARAMS)
     source_type_obj = _get_enum_obj(SourceType, source_type)
 
@@ -107,30 +73,13 @@ def _make_source_node(source_params, source_type):
     return source
 
 def _make_pv(load_node, params, num_panels, count):
-    """
-    Make a PV at the load node given, scaling kV by the number of solar panels
-
-    Args:
-        load_node: which load to add PVsystem to
-        params: any customized parameters
-        num_panels: representation of how many solar panels this PVsystem includes
-        count: how many pv already made, to not run into duplicates
-    """
     _check_valid_params(params, defaults.VALID_PV_PARAMS)
     pv : PVSystem = altdss.PVSystem.new('pv' + str(count))
     pv.Bus1 = load_node
     pv.Phases = _get_param(params, "phases", defaults.PHASES)
     pv.kV = _get_param(params, "kV", _random_param(defaults.SOLAR_PANEL_BASE_KV) * num_panels)
 
 def _make_generator(params, gen_type, count):
-    """
-    Make a generator in the circuit
-
-    Args:
-        params: any customized parameters
-        gen_type: type of generator (small, large, industrial) in string
-        count: how many generators already made, to not run into duplicates
-    """
     _check_valid_params(params, defaults.VALID_GENERATOR_PARAMS)
     gen_type_obj = _get_enum_obj(GeneratorType, gen_type)
 

pygridsim/results.py

@@ -5,15 +5,7 @@
 from altdss import altdss
 import json
 
-def query_solution(query):
-    """
-    Given a query, return the query result or indicate it is invalid
-
-    Args:
-        query: a query for the solve function
-    Return:
-        Query result or the string "Invalid" if the query is not supported
-    """
+def _query_solution(query):
     match query:
         case "Voltages":
             bus_vmags = {}
@@ -32,6 +24,6 @@ def query_solution(query):
         case _:
             return "Invalid"
 
-def export_results(results, path):
+def _export_results(results, path):
     with open(path, "w") as json_file:
         json.dump(results, json_file, indent=4)

sim.json

@@ -1,10 +1,10 @@
 {
     "Voltages": {
-        "source": 1523.4068912046298,
-        "load0": 187.13882108513008
+        "source": 1722.6218596951128,
+        "load0": 222.38058356537
     },
     "Losses": {
-        "Active Power Loss": 160914.96444476524,
-        "Reactive Power Loss": 334569.1340276267
+        "Active Power Loss": 201075.15204291482,
+        "Reactive Power Loss": 418081.9257259038
     }
 }

tests/test_circuit.py

@@ -61,8 +61,6 @@ def test_003_one_source_one_load_exhaustive(self):
                     circuit.add_load_nodes(num=1, load_type=load_type.value)
                     circuit.add_lines([("source", "load0")], line_type.value)
                     circuit.solve()
-                    #print("LineType:", line_type, "SourceType", source_type, "LoadType", load_type)
-                    #print(circuit.results(["Voltages", "Losses"]))
                     circuit.clear()