Backend state migration

.github/workflows/ci.yml

@@ -2,7 +2,7 @@ name: Unit Tests
 
 on:
   pull_request:
-    branches: [dev, main]
+    branches: [dev, main, CIRCLES-331/user-data-to-backend, 331-staging]
 
 jobs:
   event_file:
@@ -23,10 +23,10 @@ jobs:
     steps:
       - name: Checking out repository
         uses: actions/checkout@v3
-      - name: Set up Python (latest)
+      - name: Set up Python 3.12
         uses: actions/setup-python@v4
         with:
-          python-version: "3.10.5"
+          python-version: "3.12"
       - name: Install dependencies
         run: |
           python -m pip install --upgrade pip
@@ -59,10 +59,10 @@ jobs:
     steps:
       - name: Checking out repository
         uses: actions/checkout@v3
-      - name: Set up Python (latest)
+      - name: Set up Python 3.12
         uses: actions/setup-python@v4
         with:
-          python-version: "3.x"
+          python-version: "3.12"
       - name: Run frontend tests
         run: |
           cd frontend

.github/workflows/pylinter.yml

@@ -13,7 +13,7 @@ name: Pylint
 
 on:
   pull_request:
-    branches: [dev, main]
+    branches: [dev, main, CIRCLES-331/user-data-to-backend]
 
 jobs:
   build:
@@ -23,10 +23,10 @@ jobs:
 
     steps:
     - uses: actions/checkout@v3
-    - name: Set up Python ${{ matrix.python-version }}
+    - name: Set up Python
       uses: actions/setup-python@v4
       with: 
-        python-version: "3.x"
+        python-version: "3.12"
 
     - name: Install dependencies
       run: |

.gitignore

@@ -18,6 +18,7 @@ eggs/
 .eggs/
 lib/
 lib64/
+lib64
 parts/
 sdist/
 var/
@@ -72,5 +73,9 @@ tmp.*
 .idea
 **/Session.vim
 
+# secret
+SECRET
+secret.json
+secret.env
 # "sensitive" data (i.e. raw zID)
 backend/data/scrapers/enrolmentDataRaw.json

.pylintrc

@@ -75,7 +75,9 @@ disable=import-error,                     # allow import from folder.file instea
         global-statement,                 # allow use of globals. Used for filepaths and configs
         too-few-public-methods,           # need classes with zero public methods as abstract objects
         duplicate-code,                   # Code duplication due to progtype1. TODO: Fix on complete refactor
-        no-name-in-module                 # seems to be similar to import-error
+        no-name-in-module,                # seems to be similar to import-error
+        missing-module-docstring,         # allow for missing module docstrings, democratially ignored
+        useless-parent-delegation         # allow for methods that just return super().method()
       #   parameter-unpacking,      
       #   unpacking-in-except,
       #   old-raise-syntax,
@@ -449,11 +451,12 @@ good-names=i,
            k,
            ex,
            Run,
-           _
+           _,
+           f
 
 # Good variable names regexes, separated by a comma. If names match any regex,
 # they will always be accepted
-good-names-rgxs=
+good-names-rgxs=^([A-Z]{4})_FIXES
 
 # Include a hint for the correct naming format with invalid-name.
 include-naming-hint=no

.tokeignore

@@ -0,0 +1 @@
+**.json

.vscode/settings.json

@@ -2,6 +2,7 @@
     "eslint.workingDirectories": [
         "frontend"
     ],
+    "VitestRunner.executionArg": "npx --prefix frontend",
     "python.testing.unittestEnabled": false,
     "python.testing.pytestEnabled": true,
     "python.testing.cwd": "${workspaceFolder}/backend",
@@ -10,10 +11,9 @@
         "**/.hypothesis": true,
         "**/.pytest_cache": true
     },
-    "python.linting.mypyEnabled": true,
-    "python.linting.mypyArgs": [
-        "--config-file=${workspaceFolder}/backend/mypy.ini"
-    ],
     "python.analysis.typeCheckingMode": "basic",
-    "files.eol": "\n"
+    "[python]": {
+        "editor.formatOnSave": false
+    },
+    "python.analysis.autoImportCompletions": true
 }

README.md

@@ -47,4 +47,6 @@ We are a team that is part of DevSoc! See [TEAM.md](./TEAM.md) for more informat
 
 Also, special thanks to James Ji, Vincent Xiao, Hayes Choy for being the first team to work on and inspire Circles :)
 
-[For further development documentation, visit our confluence page!](https://devsoc.atlassian.net/wiki/spaces/C/pages/756966/About+Circles)
+Information to run Circles on your local machine are available in the [frontend](./frontend/README.md) and [backend](./backend/README.md) `README.md` files.
+
+For further development documentation, visit our [confluence page](https://devsoc.atlassian.net/wiki/spaces/C/pages/756966/About+Circles)!

backend/algorithms/autoplanning.py

@@ -1,10 +1,12 @@
 """ an autoplanning solver which takes in courses and spits a plan """
 from pprint import pprint
 from typing import Tuple
-from ortools.sat.python import cp_model # type: ignore
+
 from algorithms.objects.course import Course
 from algorithms.objects.user import User
+from ortools.sat.python import cp_model  # type: ignore
 from server.routers.model import CONDITIONS
+
 # Inspired by AbdallahS's code here: https://github.com/AbdallahS/planner
 # with help from Martin and MJ :)
 
@@ -51,13 +53,13 @@ def autoplan(courses: list[Course], user: User, start: Tuple[int, int], end: Tup
             model.Add(v == index).OnlyEnforceIf(b)
             model.Add(v != index).OnlyEnforceIf(b.Not())
             boolean_indexes.append(b)
-        # if the course is in term 'index', only allow 0 to m UOC to exist in that term. 
+        # if the course is in term 'index', only allow 0 to m UOC to exist in that term.
         model.AddReservoirConstraintWithActive(
             variables,
-            list(map_var_to_course(courses, var).uoc for var in variables), # this fills the resovoir by UoC units if active
-            boolean_indexes, # a course is only active if in term 'index'
+            list(map_var_to_course(courses, var).uoc for var in variables),  # this fills the resovoir by UoC units if active
+            boolean_indexes,  # a course is only active if in term 'index'
             0,
-            m # uoc_max
+            m  # uoc_max
         )
 
     # 4. enforce prereqs, only if not locked by user
@@ -73,11 +75,10 @@ def autoplan(courses: list[Course], user: User, start: Tuple[int, int], end: Tup
             map_course_to_var(course, variables)
         )
     solver = cp_model.CpSolver()
-    status: int = solver.Solve(model)
-    if status == 3 or status == 1:
-        raise Exception(f'your courses are impossible to put in these terms! Error code: {status}')
-    else:
-        return [(v.Name(), convert_to_term_year(solver.Value(v), start)) for v in variables]
+    status = solver.Solve(model)
+    if status in [cp_model.MODEL_INVALID, cp_model.INFEASIBLE]:
+        raise ValueError(f'your courses are impossible to put in these terms! Error code: {status}')
+    return [(v.Name(), convert_to_term_year(solver.Value(v), start)) for v in variables]
 
 
 if __name__ == '__main__':
@@ -115,4 +116,3 @@ def autoplan(courses: list[Course], user: User, start: Tuple[int, int], end: Tup
         (2023, 3),
         [12, 20, 20, 20, 12, 20, 20, 20, 10, 20, 20, 20]
     ))
-

backend/algorithms/cache/cache.py

@@ -4,22 +4,18 @@
 This should be run from the backend directory or via runprocessors
 """
 
-from functools import reduce
 import operator
 import re
+from functools import reduce
 from typing import Any, Literal
 
-from algorithms.cache.cache_config import (CACHE_CONFIG, CACHED_EQUIVALENTS_FILE,
-                                           CACHED_EXCLUSIONS_FILE,
-                                           CACHED_WARNINGS_FILE,
-                                           CONDITIONS_PROCESSED_FILE,
-                                           COURSE_MAPPINGS_FILE,
-                                           COURSES_PROCESSED_FILE,
-                                           MAPPINGS_FILE,
-                                           PROGRAM_MAPPINGS_FILE,
+from algorithms.cache.cache_config import (CACHE_CONFIG, CACHED_EQUIVALENTS_FILE, CACHED_EXCLUSIONS_FILE,
+                                           CACHED_WARNINGS_FILE, CONDITIONS_PROCESSED_FILE, COURSE_MAPPINGS_FILE,
+                                           COURSES_PROCESSED_FILE, MAPPINGS_FILE, PROGRAM_MAPPINGS_FILE,
                                            PROGRAMS_FORMATTED_FILE)
 from data.utility.data_helpers import read_data, write_data
 
+
 def cache_equivalents():
     """
     Reads from processed courses and stores the exclusions in a map mapping
@@ -95,36 +91,36 @@ def cache_mappings():
     def tokeniseFaculty(Faculty):
         faculty_token = "F "
         if re.search("Faculty of.+", Faculty):
-            match_object = re.search("(?<=Faculty\sof\s)[^\s\n\,]+", Faculty)
+            match_object = re.search(r"(?<=Faculty\sof\s)[^\s\n\,]+", Faculty)
         elif re.search("UNSW", Faculty):
             match_object = re.search(r"(?<=UNSW\s)[^\s\n\,]+", Faculty)
         else:
-            match_object = re.search("^([\w]+)", Faculty)
+            match_object = re.search(r"^([\w]+)", Faculty)
         if match_object is None:
-            raise Exception(f'no match found for faculty: {Faculty}')
+            raise KeyError(f'no match found for faculty: {Faculty}')
         match = match_object.group()
         faculty_token += match
         return faculty_token
 
     # Tokenise faculty using regex, e.g 'School of Psychology' -> 'S Psychology'
     def tokeniseSchool(School):
         school_token = "S "
-        if re.search("School\sof\sthe.+", School):
-            match_object = re.search("(?<=School\sof\sthe\s)[^\s\n\,]+", School)
-        elif re.search("School\sof\s.+", School):
-            match_object = re.search("(?<=School\sof\s)[^\s\n\,]+", School)
+        if re.search(r"School\sof\sthe.+", School):
+            match_object = re.search(r"(?<=School\sof\sthe\s)[^\s\n\,]+", School)
+        elif re.search(r"School\sof\s.+", School):
+            match_object = re.search(r"(?<=School\sof\s)[^\s\n\,]+", School)
         elif re.search("^(UC)", School):
-            match_object = re.search("(?<=UC\s)[^\s\n\,]+", School)
+            match_object = re.search(r"(?<=UC\s)[^\s\n\,]+", School)
             if match_object is None:
-                raise Exception(f'no match found for school: {School}')
+                raise KeyError(f'no match found for school: {School}')
             match = school_token + "UC-" +  match_object.group()
             return match
         elif re.search("UNSW", School):
-            match_object = re.search("(?<=UNSW\s)[^\s\n\,]+", School)
+            match_object = re.search(r"(?<=UNSW\s)[^\s\n\,]+", School)
         else:
-            match_object = re.search("^([\w]+)", School)
+            match_object = re.search(r"^([\w]+)", School)
         if match_object is None:
-            raise Exception(f'no match found for school: {School}')
+            raise KeyError(f'no match found for school: {School}')
         match = match_object.group()
         school_token += match
         return school_token
@@ -172,7 +168,7 @@ def cache_program_mappings():
 
     keyword_codes: dict[str, list[str]] = read_data(CACHE_CONFIG)
 
-    mappings : dict = { # TODO: make more strict
+    mappings : dict = {  # TODO: make more strict
         code: {} for code
         in reduce(operator.add, keyword_codes.values())
     }

backend/algorithms/create.py

@@ -7,52 +7,22 @@
 import re
 from typing import Optional, Tuple
 
-from algorithms.objects.categories import (
-    Category,
-    CompositeCategory,
-    ClassCategory,
-    CourseCategory,
-    FacultyCategory,
-    LevelCategory,
-    LevelCourseCategory,
-    SchoolCategory,
-)
-from algorithms.objects.conditions import (
-    CompositeCondition,
-    CoresCondition,
-    CoreqCourseCondition,
-    CourseCondition,
-    CourseExclusionCondition,
-    GradeCondition,
-    ProgramCondition,
-    ProgramExclusionCondition,
-    ProgramTypeCondition,
-    SpecialisationCondition,
-    UOCCondition,
-    WAMCondition,
-)
-from algorithms.objects.helper import (
-    Logic,
-    get_grade,
-    get_uoc,
-    get_wam,
-    is_course,
-    is_grade,
-    is_program,
-    is_program_type,
-    is_specialisation,
-    is_uoc,
-    is_wam,
-    get_level_category,
-    get_course_category
-)
+from algorithms.objects.categories import (Category, ClassCategory, CompositeCategory, CourseCategory, FacultyCategory,
+                                           LevelCategory, LevelCourseCategory, SchoolCategory)
+from algorithms.objects.conditions import (CompositeCondition, CoreqCourseCondition, CoresCondition, CourseCondition,
+                                           CourseExclusionCondition, GradeCondition, ProgramCondition,
+                                           ProgramExclusionCondition, ProgramTypeCondition, SpecialisationCondition,
+                                           UOCCondition, WAMCondition)
+from algorithms.objects.helper import (Logic, get_course_category, get_grade, get_level_category, get_uoc, get_wam,
+                                       is_course, is_grade, is_program, is_program_type, is_specialisation, is_uoc,
+                                       is_wam)
 
 # Load in cached exclusions
 CACHED_EXCLUSIONS_PATH = "algorithms/cache/exclusions.json"
 with open(CACHED_EXCLUSIONS_PATH, "r", encoding="utf8") as f:
     CACHED_EXCLUSIONS = json.load(f)
 
-def create_category(tokens) -> Tuple[Optional[Category], int]: # pylint: disable=too-many-return-statements
+def create_category(tokens) -> Tuple[Optional[Category], int]:  # pylint: disable=too-many-return-statements
     """
     Given a list of tokens starting from after the connector keyword, create
     and return the category object matching the category, as well as the current index
@@ -268,4 +238,3 @@ def make_condition(tokens, first=False, course=None) -> Tuple[Optional[Composite
             result.add_condition(cond)
 
     return result, index
-

backend/algorithms/create_program.py

@@ -6,6 +6,7 @@
 import pickle
 import re
 from typing import Dict, List
+
 from algorithms.objects.categories import Category, GenEdCategory, LevelCategory, LevelCourseCategory
 from algorithms.objects.conditions import Condition, CoresCondition, UOCCondition
 from algorithms.objects.helper import read_data
@@ -21,7 +22,7 @@ class UnparseableError(Exception):
     The given token cannot be parsed
     """
     def __init__(self, tokens: List[str] | Dict):
-        super().__init__("Unparseable tokens: {}".format(tokens))
+        super().__init__(f"Unparseable tokens: {tokens}")
 
 def process_program_conditions() -> None:
     """
@@ -84,7 +85,7 @@ def create_maturity_restriction(tokens: Dict[str, List[str]]) -> ProgramRestrict
     )
 
 def create_dependency_condition(tokens: List[str]) -> Condition:
-    """
+    r"""
     Creates a dependent condition from the tokens.
 
     Dependency Types:
@@ -107,7 +108,7 @@ def create_dependency_condition(tokens: List[str]) -> Condition:
         # Maybe assert that this is the end?
 
     # Matching LevelCategory
-    if re.match("L\d", base_token):
+    if re.match(r"L\d", base_token):
         index += 1
         level = int(base_token[1:])
         level_category = LevelCategory(level)
@@ -135,7 +136,7 @@ def create_dependency_condition(tokens: List[str]) -> Condition:
 
 
 def create_dependent_condition(tokens: List[str]) -> Category:
-    """
+    r"""
     Creates a dependency condition from the tokens.
 
     Need to worry about:
@@ -160,4 +161,3 @@ def create_dependent_condition(tokens: List[str]) -> Category:
 
 if __name__ == "__main__":
     create_all_program_conditions()
-