[Datasets] Package update (#114)

Author: shorodilov

.github/workflows/sonarcloud.yml

@@ -47,7 +47,7 @@ jobs:
             -Dsonar.projectKey=edu-python-course_problem-sets
             -Dsonar.organization=edu-python-course
             -Dsonar.python.coverage.reportPaths=coverage.xml -X
-            -Dsonar.coverage.exclusions=**/scripts/**,**/__init__,**/__main__,**/tests/** -X
+            -Dsonar.coverage.exclusions=**/scripts/**,**/__init__*,**/__main__*,**/tests/** -X
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}  # Needed to get PR information, if any
           SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}

src/datasets/__init__.py

@@ -12,16 +12,32 @@
 """
 
 __all__ = [
-    "swap_dict",
-    "get_low_student",
-    "get_top_student",
-    "get_both_top_low_students",
     "get_bricks_count",
-    "get_position_frequency",
-    "get_least_bricks_position",
     "get_least_bricks_count",
+    "get_least_bricks_position",
+    "get_position_frequency",
     "filter_by_values",
-    "flatten",
+    "flatten_list",
+    "swap_dict",
+    "swap_dict_loop",
+    "get_avg_score",
+    "get_both_top_low_students",
+    "get_low_student",
+    "get_top_student",
 ]
 
-from datasets.func import *
+from datasets.bricks import (
+    get_bricks_count,
+    get_least_bricks_count,
+    get_least_bricks_position,
+    get_position_frequency
+)
+from datasets.filters import filter_by_values
+from datasets.flatten import flatten_list
+from datasets.func import swap_dict, swap_dict_loop
+from datasets.students import (
+    get_avg_score,
+    get_both_top_low_students,
+    get_low_student,
+    get_top_student
+)

src/datasets/bricks.py

@@ -0,0 +1,111 @@
+"""
+Brick wall challenge functions
+
+"""
+
+from typing import Dict, List
+
+
+def get_bricks_count(structure: List[List[int]]) -> int:
+    """
+    Return number of bricks in the wall structure
+
+    :param structure: represents wall structure as sequences of integers
+    :type structure: list
+
+    :return: total number of bricks in the entire wall structure
+    :rtype: int
+
+    Usage:
+
+    >>> assert get_bricks_count([[1], [1], [1]]) == 3
+    >>> assert get_bricks_count([[1, 1, 1], [1, 1, 1]]) == 6
+    >>> assert get_bricks_count([[2, 1, 2], [1, 1, 1, 1, 1]]) == 8
+
+    """
+
+    return sum(len(row) for row in structure)
+
+
+def get_position_frequency(structure: List[List[int]]) -> Dict[int, int]:
+    """
+    Return a matrix of position-bricks pairs for a structure
+
+    :param structure: represents wall structure as sequences of integers
+    :type structure: list
+
+    :return: the position - frequency matrix
+    :rtype: dict
+
+    Usage:
+
+    >>> assert get_position_frequency([[1], [1], [1]]) == {}
+    >>> assert get_position_frequency([[1, 2], [2, 1], [3]]) = {1: 1, 2: 1}
+    >>> assert get_position_frequency([[1, 1, 1], [1, 1, 1]]) = {1: 2, 2: 2}
+
+    """
+
+    structure_matrix = {}
+
+    for row in structure:
+        row_length = 0
+        for brick_length in row[:-1]:
+            row_length += brick_length
+            if row_length not in structure_matrix:
+                structure_matrix[row_length] = 0
+            structure_matrix[row_length] += 1
+
+    return structure_matrix
+
+
+def get_least_bricks_position(structure: List[List[int]]) -> int:
+    """
+    Return a pointer to the weakest line in the structure
+
+    :param structure: represents wall structure as sequences of integers
+    :type structure: list
+
+    :return: the distance from the left edge to the weakest line location
+    :rtype: int
+
+    This function uses helper function ``get_structure_matrix`` to build
+    the matrix of distances from the left edge of the "wall".
+
+    Usage:
+
+    >>> assert get_least_bricks_position([[1], [1], [1]]) == 0
+    >>> assert get_least_bricks_position([[1, 1, 1], [1, 1, 1]]) == 1
+
+    """
+
+    matrix = get_position_frequency(structure)
+    if not matrix:
+        return 0
+
+    return max(matrix, key=matrix.get)  # type: ignore
+
+
+def get_least_bricks_count(structure: List[List[int]]) -> int:
+    """
+    Return the least number of bricks in a vertical line
+
+    :param structure: represents wall structure as sequences of integers
+    :type structure: list
+
+    :return: minimum number of bricks in a line
+    :rtype: int
+
+    Usage:
+
+    >>> assert get_least_bricks_count([[1], [1], [1]]) == 3
+    >>> assert get_least_bricks_count([[1, 2], [2, 1], [3], [1, 1, 1]]) == 2
+    >>> assert get_least_bricks_count([[1, 1, 1], [1, 1, 1]]) == 0
+
+    """
+
+    max_value: int = 0
+    matrix = get_position_frequency(structure)
+    for count in matrix.values():
+        max_value = max(max_value, count)
+
+    return len(structure) - max_value

src/datasets/filters.py

@@ -0,0 +1,62 @@
+"""
+Dataset filtering functions
+
+"""
+
+from typing import Any, Dict, Hashable, List, Optional, Set
+
+
+def filter_by_values(origin: List[Dict[str, Hashable]],
+                     keys: Optional[List[str]] = None
+                     ) -> List[Dict[str, Any]]:
+    """
+    Return a filtered datasets by unique values in a given keys sets
+
+    :param origin: an original dataset with entries to filter
+    :type origin: list
+    :param keys: a collection of keys to use for filtering
+    :type keys: list, optional
+
+    :return: a filtered dataset
+    :rtype: list
+
+    The origin dataset is a list of dictionaries. All the dictionaries have
+    the same set of keys of a string type. All dictionaries values are of
+    a hashable type.
+
+    In case no data provided (``origin`` is an empty list) the function will
+    return an empty list.
+
+    The keys parameter is used to set the dictionary keys to filter unique
+    values. Keys list is considered to be validated before passing to this
+    function, all values (if any) are valid. In case this parameter is
+    omitted - all available keys should be used.
+
+    Usage:
+
+    >>> ds = [{"x": 1, "y": 2, "z": 3}, {"x": 0, "y": 2, "z": 3}]
+    >>> assert filter_by_values(ds, ["x"]) == ds       # the same as origin
+    >>> assert filter_by_values(ds, ["x", "z"]) == ds  # the same as origin
+    >>> assert filter_by_values(ds, ["y"]) == [{"x": 1, "y": 2, "z": 3}]
+    >>> assert filter_by_values(ds, ["y", "z"]) == [{"x": 1, "y": 2, "z": 3}]
+
+    """
+
+    # check base cases
+    if not origin:
+        return []
+
+    # declare variables to store runtime data
+    filtered_dataset: List[Dict[str, Hashable]] = []
+    filtered_values: Set[int] = set()
+
+    keys = keys or origin[0].keys()  # type: ignore
+    for entry in origin:
+        entry_values = hash(tuple(map(entry.get, keys)))  # type: ignore
+        if entry_values in filtered_values:
+            continue
+
+        filtered_values.add(entry_values)
+        filtered_dataset.append(entry)
+
+    return filtered_dataset

src/datasets/flatten.py

@@ -0,0 +1,36 @@
+"""
+Data flatten functions
+
+"""
+
+from typing import List, Union
+
+NestedIntList = Union[int, List["NestedIntList"]]
+
+
+def flatten_list(origin: List[NestedIntList]) -> List[int]:
+    """
+    Flattens a list of integers and nested lists of integers
+
+    :param origin: an original list
+
+    :return: a single-level list of integers
+
+    Usage:
+
+    >>> assert flatten_list([1, 2, 3]) == [1, 2, 3]
+    >>> assert flatten_list(([[1], [2], [3]])) == [1, 2, 3]
+    >>> assert flatten_list([1, [2, 3]]) == [1, 2, 3]
+    >>> assert flatten_list([1, [[2], [3]]]) == [1, 2, 3]
+
+    """
+
+    result: List[int] = []
+
+    for item in origin:
+        if isinstance(item, list):
+            result.extend(flatten_list(item))
+        else:
+            result.append(item)
+
+    return result