Update 2023.09.1 (#104)

- SonarCloud integration

Author: shorodilov

.github/workflows/sonarcloud.yml

@@ -0,0 +1,53 @@
+name: Collect coverage report for SonarCloud
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    types:
+      - opened
+      - synchronize
+      - reopened
+    branches:
+      - master
+      - devel
+
+jobs:
+  sonarcloud:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          fetch-depth: 0  # Shallow clones should be disabled for a better relevancy of analysis
+      - name: Set up Python
+        uses: actions/setup-python@v2
+        with:
+          python-version: "3.9"
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install pytest pytest-cov
+      - name: Install source packages
+        run: |
+          pip install -e .
+      - name: Collect coverage
+        run: |
+          pytest --cov=src --cov-report=xml --cov-config=pyproject.toml --cov-branch
+      - name: Upload coverage report
+        uses: actions/upload-artifact@v2
+        with:
+          name: coverage
+          path: ./coverage.xml
+      - name: SonarCloud Scan
+        uses: SonarSource/sonarcloud-github-action@master
+        with:
+          args:
+            -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
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}  # Needed to get PR information, if any
+          SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}

.gitignore

@@ -24,6 +24,7 @@ __pycache__
 # coverage reports
 *.coverage.db
 *.coverage
+coverage.*
 
 # local databases
 pgdata/

poetry.lock

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "problem-sets"
-version = "2023.08.1"
+version = "2023.09.1"
 description = "Challenges and solutions for the Python training course"
 license = "MIT"
 authors = [
@@ -67,10 +67,14 @@ addopts = "--cov=src --verbose"
 testpaths = ["tests"]
 
 [tool.coverage.run]
+relative_files = true
+branch = true
 source = ["src"]
 omit = [
-    "*__init__*",
-    "*__main__*"
+    "**/__init__",
+    "**/__main__",
+    "**/scripts/**",
+    "**/tests/**",
 ]
 
 [tool.coverage.report]
@@ -81,10 +85,11 @@ exclude_lines = [
 
 [tool.mypy]
 files = "src,tests"
+exclude = "scripts"
 
 [tool.pylint."MASTER"]
 fail-under = 8
-ignore = ["tests"]
+ignore = ["tests", "scripts"]
 persistent = true
 
 [tool.pylint."MESSAGES CONTROL"]

pyproject.toml

@@ -0,0 +1,61 @@
+"""
+This module demonstrates the mutable nature of objects
+
+"""
+
+import logging
+from typing import Any, List, Optional
+
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+
+
+def change_mutable_v1(value: Any, mutable: List[Any]) -> List[Any]:
+    """This function will change mutable argument"""
+
+    mutable.append(value)
+    return mutable
+
+
+# noinspection PyDefaultArgument
+def change_mutable_v2(value: Any,
+                      mutable: Optional[List[Any]] = []) -> List[Any]:
+    """This function will change default mutable object"""
+
+    mutable.append(value)
+    return mutable
+
+
+def change_valid(value: Any,
+                 mutable: Optional[List[Any]] = None) -> List[Any]:
+    """
+    This function wouldn't change defaults,
+    but will change mutable argument.
+    """
+
+    mutable = mutable or []
+    mutable.append(value)
+
+    return mutable
+
+
+if __name__ == "__main__":
+    mutable_obj1 = []
+    change_mutable_v1(1, mutable_obj1)
+    mutable_obj1 += [2]  # [1, 2], because it was changed by "change_mutable"
+
+    logger.info(f"{mutable_obj1 = }")
+
+    mutable_obj2 = change_mutable_v2(10)  # expected: [10]
+    mutable_obj3 = change_mutable_v2(20)  # expected: [20], but [10, 20]
+
+    logger.info(f"{mutable_obj2 = }")
+    logger.info(f"{mutable_obj3 = }")
+
+    mutable_obj4 = change_valid(100)  # expected: [100]
+    mutable_obj5 = change_valid(200)  # expected: [200]
+    mutable_obj6 = change_valid(3, mutable_obj1)  # expected: [1, 2, 3]
+
+    logger.info(f"{mutable_obj4 = }")
+    logger.info(f"{mutable_obj5 = }")
+    logger.info(f"{mutable_obj6 = }")

src/basics/__init__.py

@@ -25,7 +25,7 @@
 Balanced Parentheses
 --------------------
 
-A parentheses is said to be balanced if each left parenthesis has its
+A parentheses are said to be balanced if each left parenthesis has its
 respective right parenthesis to match its pair in a well-nested format.
 
 .. autofunction:: are_parentheses_balanced
@@ -39,4 +39,4 @@
     "get_longest_uniq_length",
 ]
 
-from .func import *
+from sequences.func import *

src/basics/scripts/__init__.py

@@ -3,7 +3,6 @@
 
 """
 
-import string
 from typing import List, Union
 
 from calc import get_squares
@@ -38,16 +37,15 @@ def is_palindrome(origin: Union[str, int], /) -> bool:
     """
 
     origin = str(origin).lower()
-    skip_chars: str = string.punctuation + string.whitespace
     left: int = 0
     right: int = len(origin) - 1
 
     while left < right:
-        if origin[left] in skip_chars:
+        if not origin[left].isalnum():
             left += 1
             continue
 
-        if origin[right] in skip_chars:
+        if not origin[right].isalnum():
             right -= 1
             continue
 
@@ -64,7 +62,7 @@ def get_longest_palindrome(origin: str, /) -> str:
     """
     Return the longest palindrome substring from the given input
 
-    :param origin:
+    :param origin: an origin string to find palindromes in
     :type origin: str
 
     :return: the longest palindrome
@@ -80,6 +78,20 @@ def get_longest_palindrome(origin: str, /) -> str:
     size: int = len(origin)
 
     def expand(left: int, right: int) -> int:
+        """
+
+        This inner function uses closure to "size" and "origin" objects
+        from outer score, and tries to expand to left and right from
+        the specified index of the origin string, until palindrome and
+        expansion checks are pass.
+
+        :param left: left starting expansion index
+        :type left: int
+        :param right: right starting expansion index
+        :type right: int
+
+        """
+
         while left >= 0 and right < size and origin[left] == origin[right]:
             left -= 1
             right += 1
@@ -123,10 +135,10 @@ def get_palindrome_squares(limit: int, /) -> List[int]:
 
     Range begins with 0.
 
-    :param limit:
+    :param limit: the range limitation value
     :type limit: int
 
-    :return:
+    :return: a list of palindrome squares within a range
     :rtype: list
 
     """
@@ -205,3 +217,70 @@ def get_longest_uniq_length(origin: str, /) -> int:
         length = max(length, right_idx - left_idx + 1)
 
     return length
+
+
+def add_spaces(origin: str) -> str:
+    """
+    Return modified string with whitespaces before capital letters
+
+    An origin string may contain letters in upper case. The function removes
+    any white spaces present in the initial data, and transform the string
+    in a way to add spaces only before letters in upper case.
+
+    :param origin: an original string
+    :rtype: str
+
+    :return: string with white spaces before capital letters
+    :rtype: str
+
+    Usage:
+
+    >>> assert add_spaces("camelCase") == "camel Case"
+    >>> assert add_spaces(" John Doe ") == "John Doe"
+    >>> assert add_spaces("racecar") == "racecar"
+
+    """
+
+    # remove white spaces, if any
+    origin = origin.replace(" ", "")
+
+    return "".join(f" {c}" if c.isupper() else c for c in origin).lstrip()
+
+
+def get_consecutive_slices(origin: str, n: int) -> List[str]:
+    """
+    Return possible slices of string as a collection consecutive lists
+
+    Given a string of digits and an integer `n`, this function returns all
+    consecutive slices of length `n` from the string.
+
+    :param origin: the input string of digits
+    :type origin: str
+    :param n: the length of slices to be extracted
+    :type n: int
+
+    :return: a list containing consecutive slices of length "n"
+    :rtype: list
+
+    :raise: ValueError
+
+    Usage:
+
+    >>> assert get_consecutive_slices("0123", 1) == [[0], [1], [2], [3]]
+    >>> assert get_consecutive_slices("0123", 2) == [[0, 1], [1, 2], [2, 3]]
+    >>> assert get_consecutive_slices("0123", 3) == [[0, 1, 2], [1, 2, 3]]
+
+    """
+
+    size: int = len(origin)
+    if size < n:
+        raise ValueError("slice size is bigger than origin length")
+
+    result = []
+    idx = 0
+
+    while idx <= size - n:
+        result.append(origin[idx:idx + n])
+        idx += 1
+
+    return result

src/basics/scripts/demo_mutable.py

@@ -1,3 +1,5 @@
+import pytest
+
 import sequences
 
 
@@ -70,3 +72,24 @@ def test_get_longest_uniq_sequence_length():
     assert sequences.get_longest_uniq_length("abcdefg") == 7
     assert sequences.get_longest_uniq_length("abcacba") == 3
     assert sequences.get_longest_uniq_length("hwccjayhiszbmomlqkem") == 11
+
+
+def test_add_space():
+    assert sequences.add_spaces("") == ""
+    assert sequences.add_spaces("test_test") == "test_test"
+    assert sequences.add_spaces("JohnDoe") == "John Doe"
+    assert sequences.add_spaces("John Doe") == "John Doe"
+
+
+def test_get_consecutive_slices():
+    assert sequences.get_consecutive_slices("0123", 1) == ["0", "1", "2", "3"]
+    assert (
+        sequences.get_consecutive_slices("0123", 2) == ["01", "12", "23"]
+    )
+    assert (
+        sequences.get_consecutive_slices("0123", 3) == ["012", "123"]
+    )
+
+    with pytest.raises(ValueError,
+                       match="slice size is bigger than origin length"):
+        sequences.get_consecutive_slices("0123", 5)