update

Author: abdullahau

Diff for: Applications/Pacman/Notes/1 - Vectors.md

@@ -106,3 +106,5 @@ That's not terribly useful, it just tells you where that object is in memory. So
 def __str__(self):
     return "<"+str(self.x)+", "+str(self.y)+">"
 ```
+
+Reference: [Website](https://pacmancode.com/)

Diff for: course-submission-files/hy-adv-course-in-prog-exam-15062024/Exam15062024-Exercise1/src/exercise1.py

@@ -0,0 +1 @@
+# Write your solution to exercise 1 here

Diff for: course-submission-files/hy-adv-course-in-prog-exam-15062024/Exam15062024-Exercise1/test/__init__.py

@@ -0,0 +1,2 @@
+from .points import points
+from .runner import TMCTestRunner

Diff for: course-submission-files/hy-adv-course-in-prog-exam-15062024/Exam15062024-Exercise1/tmc/__init__.py

@@ -0,0 +1,39 @@
+from unittest import TestProgram
+from .runner import TMCTestRunner
+import sys
+
+django_defined = False
+try:
+    with open('.tmcproject.yml') as f:
+        for line in f:
+            try:
+                (key, value) = line.split(":")
+                if key.strip().lower() == "django":
+                    django_defined = str(value.strip().lower())
+            except ValueError:
+                pass
+except FileNotFoundError:
+    pass
+
+if django_defined:
+    import os
+    import django
+    import django.conf
+    from django.test.utils import get_runner
+    from django.conf import settings
+    os.environ['DJANGO_SETTINGS_MODULE'] = django_defined + '.config.settings'
+    django.setup()
+
+if sys.argv.__len__() > 1 and sys.argv[1] == 'available_points':
+    TMCTestRunner().available_points()
+    sys.exit()
+
+if django_defined:
+    settings.TEST_RUNNER = 'tmc.django.TMCDiscoverRunner'
+    TestRunner = get_runner(settings)
+    test_runner = TestRunner()
+    failures = test_runner.run_tests(["test"])
+    sys.exit(bool(failures))
+
+main = TestProgram
+main(testRunner=TMCTestRunner, module=None, failfast=False, buffer=True)

Diff for: course-submission-files/hy-adv-course-in-prog-exam-15062024/Exam15062024-Exercise1/tmc/__main__.py

@@ -0,0 +1,6 @@
+from django.test.runner import DiscoverRunner
+from tmc import runner
+
+
+class TMCDiscoverRunner(DiscoverRunner):
+    test_runner = runner.TMCTestRunner

Diff for: course-submission-files/hy-adv-course-in-prog-exam-15062024/Exam15062024-Exercise1/tmc/django.py

@@ -0,0 +1,50 @@
+from inspect import isclass, isfunction
+from collections import defaultdict
+
+point_register = {'suite': defaultdict(list), 'test': defaultdict(list)}
+
+
+def qualifier(test):
+    return "%s.%s" % (test.__module__, test.__qualname__)
+
+
+def save_points(o, points, dst):
+    q = qualifier(o)
+    dst[q] += filter(lambda point: point not in dst[q], points)
+
+
+def points(*points):
+
+    def points_wrapper(o):
+        if isclass(o):
+            save_points(o, points, point_register['suite'])
+        elif isfunction(o):
+            save_points(o, points, point_register['test'])
+        else:
+            raise Exception("Expected decorator object '%s' type to be Class or Function but was %s." % (o, type(o)))
+        return o
+
+    if not points:
+        raise Exception("You need to define at least one point in the points decorator declaration")
+    for point in points:
+        if type(point) is not str:
+            msg = "Points decorator argument '%s' needs to be a string, but was %s." % (point, type(point).__name__)
+            raise Exception(msg)
+    return points_wrapper
+
+
+def _parse_points(test):
+    name = _name_test(test)
+    testPoints = point_register['test']
+    points = testPoints[name]
+    key = name[:name.rfind('.')]
+    suitePoints = point_register['suite'][key]
+    points += suitePoints
+    return points
+
+
+def _name_test(test):
+    module = test.__module__
+    classname = test.__class__.__name__
+    testName = test._testMethodName
+    return module + '.' + classname + '.' + testName

Diff for: course-submission-files/hy-adv-course-in-prog-exam-15062024/Exam15062024-Exercise1/tmc/points.py

@@ -0,0 +1,57 @@
+import importlib
+
+class Reflect:
+    def __init__(self, modulename:str = "", classname:str = ""):
+        self.__classname = classname
+        self.__modulename = modulename
+        self.__cls = None
+
+    def load_class(self):
+        try:
+            self.__cls = getattr(importlib.import_module(self.__modulename), self.__classname)
+            return self.__cls
+        except Exception as e:
+            return None
+
+    def load_object(self, *params):
+        try:
+            if not self.__cls:
+                self.load_class()
+            self.__obj = self.cls(*params)
+            return self.__obj
+        except Exception as e:
+            print(e)
+            return None
+
+    def set_object(self, obj):
+        self.__obj = obj
+
+    @property
+    def cls(self):
+        return self.__cls
+
+    @property
+    def object(self):
+        return self.__obj
+
+    def list_attributes(self, filter_builtin = False):
+        if filter_builtin:
+            return [x for x in dir(self.__obj) if not x.startswith("__")]
+        return dir(self.__obj)
+
+    def has_attribute(self, attribute: str):
+        if attribute in dir(self.__obj):
+            return True
+        if ("_" + self.__classname + attribute) in dir(self.__obj):
+            return True
+        return False
+
+    def get_attribute(self, attribute: str):
+        if attribute in dir(self.__obj):
+            return getattr(self.__obj, attribute)
+        elif ("_" + self.__classname + attribute) in dir(self.__obj):
+            return getattr(self.__obj, "_" + self.__classname + attribute)
+        return None 
+
+    def list_public_members(self):
+        return [x for x in dir(self.__obj) if not x.startswith("_")]

Diff for: course-submission-files/hy-adv-course-in-prog-exam-15062024/Exam15062024-Exercise1/tmc/reflect.py

@@ -0,0 +1,52 @@
+from unittest.runner import TextTestResult
+from .points import _parse_points, _name_test
+import atexit
+import json
+import traceback
+
+results = []
+
+
+class TMCResult(TextTestResult):
+
+    def __init__(self, stream, descriptions, verbosity):
+        super(TMCResult, self).__init__(stream, descriptions, verbosity)
+
+    def startTest(self, test):
+        super(TMCResult, self).startTest(test)
+
+    def addSuccess(self, test):
+        super(TMCResult, self).addSuccess(test)
+        self.addResult(test, 'passed')
+
+    def addFailure(self, test, err):
+        super(TMCResult, self).addFailure(test, err)
+        self.addResult(test, 'failed', err)
+
+    def addError(self, test, err):
+        super(TMCResult, self).addError(test, err)
+        self.addResult(test, 'errored', err)
+
+    def addResult(self, test, status, err=None):
+        points = _parse_points(test)
+        message = ""
+        backtrace = []
+        if err is not None:
+            message = str(err[1])
+            backtrace = traceback.format_tb(err[2])
+
+        details = {
+            'name': _name_test(test),
+            'status': status,
+            'message': message,
+            'passed': status == 'passed',
+            'points': points,
+            'backtrace': backtrace
+        }
+        results.append(details)
+
+    # TODO: Do not do this if not using TMCTestRunner
+    @atexit.register
+    def write_output():
+        with open('.tmc_test_results.json', 'w', encoding='utf8') as f:
+            json.dump(results, f, ensure_ascii=False)

Diff for: course-submission-files/hy-adv-course-in-prog-exam-15062024/Exam15062024-Exercise1/tmc/result.py

@@ -0,0 +1,36 @@
+from unittest import TextTestRunner, TestLoader
+from .result import TMCResult
+from .points import _parse_points, _name_test
+from itertools import chain
+import json
+
+
+class TMCTestRunner(TextTestRunner):
+    """A test runner for TMC exercises.
+    """
+
+    resultclass = TMCResult
+
+    def __init__(self, *args, **kwargs):
+        super(TMCTestRunner, self).__init__(*args, **kwargs)
+
+    def run(self, test):
+        print('Running tests with some TMC magic...')
+        return super(TMCTestRunner, self).run(test)
+
+    def available_points(self):
+        testLoader = TestLoader()
+        tests = testLoader.discover('.', 'test*.py', None)
+        try:
+            tests = list(chain(*chain(*tests._tests)))
+        except Exception as error:
+            print("Received following Exception:", error)
+            tests.debug()
+
+        points = map(_parse_points, tests)
+        names = map(_name_test, tests)
+
+        result = dict(zip(names, points))
+
+        with open('.available_points.json', 'w') as f:
+            json.dump(result, f, ensure_ascii=False)