Merge branch 'canbula:master' into master

Author: berrkayy

.github/workflows/python-app-week-05.yml

@@ -0,0 +1,40 @@
+# This workflow will install Python dependencies, run tests and lint with a single version of Python
+# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-python
+
+name: Week05 Homework
+
+on:
+  push:
+    branches: ["master"]
+    paths: ["Week05/**"]
+  pull_request:
+    branches: ["master"]
+    paths: ["Week05/**"]
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v3
+      - name: Set up Python 3.12
+        uses: actions/setup-python@v3
+        with:
+          python-version: "3.12"
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install flake8 pytest
+          if [ -f requirements.txt ]; then pip install -r requirements.txt; fi
+      - name: Lint with flake8
+        run: |
+          # stop the build if there are Python syntax errors or undefined names
+          flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics
+          # exit-zero treats all errors as warnings. The GitHub editor is 127 chars wide
+          flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics
+      - name: Test with pytest
+        run: |
+          pytest -q --tb=no 'Week05/test_emails.py'

Week01/info_batuhan_keskin.py

@@ -0,0 +1,2 @@
+student_id = "230315022"
+full_name = "Batuhan Keskin"

Week01/info_ferhat_kilic.py

@@ -0,0 +1,2 @@
+student_id = "220315050"
+full_name = "Ferhat Kılıç"

Week02/types_hilmican_karadag.py

@@ -0,0 +1,4 @@
+my_int = 10
+my_float = 3.14
+my_bool = True
+my_complex = 3 + 9j

Week03/pyramid_hilmican_karadag.py

@@ -0,0 +1,10 @@
+def calculate_pyramid_height(number_of_blocks):
+    height = 0
+    blocks_needed = 1
+
+    while number_of_blocks >= blocks_needed:
+        number_of_blocks -= blocks_needed
+        height += 1
+        blocks_needed += 1
+
+    return height

Week03/sequences_hilmican_karadag.py

@@ -0,0 +1,26 @@
+def remove_duplicates(seq: list) -> list:
+    """
+    This function removes duplicates from a list.
+    """
+    result = []
+    for item in seq:
+        if item not in result:
+            result.append(item)
+    return result
+
+
+def list_counts(seq: list) -> dict:
+    """
+    This function counts the number of occurrences of each item in a list.
+    """
+    counts = {}
+    for item in seq:
+        counts[item] = counts.get(item, 0) + 1
+    return counts
+
+
+def reverse_dict(d: dict) -> dict:
+    """
+    This function reverses the keys and values of a dictionary.
+    """
+    return {value: key for key, value in d.items()}

Week04/decorators_hilmican_karadag.py

@@ -0,0 +1,58 @@
+import functools
+import time
+import tracemalloc
+
+
+def performance(fn):
+    """
+    Decorator that measures execution time and memory of the wrapped function.
+
+    Statistics are stored as attributes on the decorator itself:
+
+    - ``performance.counter``: number of decorated-function calls
+    - ``performance.total_time``: total time spent in seconds
+    - ``performance.total_mem``: total memory consumed in bytes
+
+    :param fn: the function to decorate
+    :type fn: callable
+    :return: the wrapped function
+    :rtype: callable
+    """
+
+    @functools.wraps(fn)
+    def wrapper(*args, **kwargs):
+        started_here = not tracemalloc.is_tracing()
+        if started_here:
+            tracemalloc.start()
+        tracemalloc.reset_peak()
+        mem_before = tracemalloc.get_traced_memory()[0]
+        start = time.perf_counter()
+
+        try:
+            return fn(*args, **kwargs)
+        finally:
+            elapsed = time.perf_counter() - start
+            peak = tracemalloc.get_traced_memory()[1]
+            if started_here:
+                tracemalloc.stop()
+            performance.counter += 1
+            performance.total_time += elapsed
+            performance.total_mem += max(peak - mem_before, 0)
+
+    return wrapper
+
+
+performance.counter = 0
+performance.total_time = 0.0
+performance.total_mem = 0
+
+
+if __name__ == "__main__":
+
+    @performance
+    def build_list(n: int) -> list[int]:
+        return [i * i for i in range(n)]
+
+    build_list(100_000)
+    build_list(50_000)
+    print(performance.counter, performance.total_time, performance.total_mem)

Week05/test_emails.py

@@ -0,0 +1,133 @@
+import os
+import pytest
+
+
+files = [f for f in os.listdir(os.path.dirname(__file__)) if f.startswith("emails")]
+for f in files:
+    exec("import " + f[:-3] + " as " + f[:-3])
+
+
+# test the file if it has the Emails class
+def test_names():
+    for f in files:
+        assert "Emails" in dir(eval(f[:-3])), "Emails is not defined in " + f[:-3]
+
+
+# test the Emails class if it is a subclass of list
+def test_subclass():
+    for f in files:
+        assert issubclass(eval(f[:-3]).Emails, list), (
+            "Emails is not a subclass of list in " + f[:-3]
+        )
+
+
+# check if the Emails class is an instance of the list class
+def test_instance():
+    for f in files:
+        assert isinstance(eval(f[:-3]).Emails([]), list), (
+            "Emails is not an instance of list in " + f[:-3]
+        )
+
+
+# test the Emails class if it has the validate method
+def test_validate():
+    for f in files:
+        assert "validate" in dir(eval(f[:-3]).Emails), (
+            "validate is not defined in " + f[:-3]
+        )
+        assert callable(eval(f[:-3]).Emails.validate), (
+            "validate is not callable in " + f[:-3]
+        )
+
+
+# test the Emails class if it has the __init__ method
+def test_init():
+    for f in files:
+        assert "__init__" in dir(eval(f[:-3]).Emails), (
+            "__init__ is not defined in " + f[:-3]
+        )
+        assert callable(eval(f[:-3]).Emails.__init__), (
+            "__init__ is not callable in " + f[:-3]
+        )
+
+
+# test the Emails class if it has the __repr__ method
+def test_repr():
+    for f in files:
+        assert "__repr__" in dir(eval(f[:-3]).Emails), (
+            "__repr__ is not defined in " + f[:-3]
+        )
+        assert callable(eval(f[:-3]).Emails.__repr__), (
+            "__repr__ is not callable in " + f[:-3]
+        )
+
+
+# check Emails class can reproduce itself with the __repr__ method
+def test_repr_output():
+    for f in files:
+        assert (
+            repr(eval(f[:-3]).Emails(["bora.canbula@cbu.edu.tr", "bora@canbula.com"]))
+            == (
+                eval(f[:-3]).Emails(["bora.canbula@cbu.edu.tr", "bora@canbula.com"])
+            ).__repr__()
+        ), (
+            "The Emails class does not reproduce itself with the __repr__ method in "
+            + f[:-3]
+        )
+
+
+# test the Emails class if it has the __str__ method
+def test_str():
+    for f in files:
+        assert "__str__" in dir(eval(f[:-3]).Emails), (
+            "__str__ is not defined in " + f[:-3]
+        )
+        assert callable(eval(f[:-3]).Emails.__str__), (
+            "__str__ is not callable in " + f[:-3]
+        )
+
+
+# check if the validate method allows only strings
+def test_validate_strings():
+    for f in files:
+        with pytest.raises(ValueError) as e:
+            eval(f[:-3]).Emails([1, 2, 3])
+            assert str(e.type) == "<class 'ValueError'>", (
+                "The validate method does not allow only strings in " + f[:-3]
+            )
+
+
+# check if the validate method allows only valid email addresses, and raises ValueError otherwise
+def test_validate_emails():
+    for f in files:
+        with pytest.raises(ValueError) as e:
+            eval(f[:-3]).Emails(["bora.canbula@cbu.edu.tr", "canbula.com"])
+            assert str(e.type) == "<class 'ValueError'>", (
+                "The validate method does not allow only valid email addresses in "
+                + f[:-3]
+            )
+        with pytest.raises(ValueError) as e:
+            eval(f[:-3]).Emails(["bora@canbulacom"])
+            assert str(e.type) == "<class 'ValueError'>", (
+                "The validate method does not allow only valid email addresses in "
+                + f[:-3]
+            )
+
+
+# check Emails class does not allow duplicate email addresses, the order is not important
+def test_validate_duplicates():
+    for f in files:
+        assert (
+            eval(f[:-3])
+            .Emails(
+                [
+                    "bora.canbula@cbu.edu.tr",
+                    "bora@canbula.com",
+                    "bora.canbula@cbu.edu.tr",
+                ]
+            )
+            .data.count("bora.canbula@cbu.edu.tr")
+            == 1
+        ), (
+            "The Emails class does not allow duplicate email addresses in " + f[:-3]
+        )