#33 Adds cli support for students endpoint. by Piotr

Author: caseneuve

cli/pa

@@ -3,9 +3,10 @@
 import typer
 
 from cli import django
+from cli import path
 from cli import schedule
+from cli import students
 from cli import webapp
-from cli import path
 
 help = """This is a new experimental PythonAnywhere cli client.
 
@@ -14,9 +15,10 @@ It was build with typer & click under the hood.
 
 app = typer.Typer(help=help)
 app.add_typer(django.app, name="django", help="Makes Django Girls tutorial projects deployment easy")
+app.add_typer(path.app, name="path", help="Perform some operations on files")
 app.add_typer(schedule.app, name="schedule", help="Manage scheduled tasks")
+app.add_typer(students.app, name="students", help="Perform some operations on students")
 app.add_typer(webapp.app, name="webapp", help="Everything for web apps")
-app.add_typer(path.app, name="path", help="Perform some operations on files")
 
 
 if __name__ == "__main__":

cli/students.py

@@ -0,0 +1,98 @@
+import sys
+
+import typer
+
+from pythonanywhere.scripts_commons import get_logger
+from pythonanywhere.students import Students
+
+app = typer.Typer()
+
+
+def setup(quiet: bool) -> Students:
+    logger = get_logger(set_info=True)
+    if quiet:
+        logger.disabled = True
+    return Students()
+
+
+@app.command()
+def get(
+    numbered: bool = typer.Option(
+        False, "-n", "--numbered", help="Add ordering numbers."
+    ),
+    quiet: bool = typer.Option(
+        False, "-q", "--quiet", help="Disable additional logging."
+    ),
+    raw: bool = typer.Option(
+        False, "-a", "--raw", help="Print list of usernames from the API response."
+    ),
+    sort: bool = typer.Option(False, "-s", "--sort", help="Sort alphabetically"),
+    sort_reverse: bool = typer.Option(
+        False, "-r", "--reverse", help="Sort in reverse order"
+    ),
+):
+    """
+    Get list of student usernames.
+    """
+
+    api = setup(quiet)
+    students = api.get()
+
+    if students is None or students == []:
+        sys.exit(1)
+
+    if raw:
+        typer.echo(students)
+        sys.exit()
+
+    if sort or sort_reverse:
+        students.sort(reverse=sort_reverse)
+
+    for number, student in enumerate(students, start=1):
+        line = f"{number:>3}. {student}" if numbered else student
+        typer.echo(line)
+
+
+@app.command()
+def delete(
+    student: str = typer.Argument(..., help="Username of a student to be removed."),
+    quiet: bool = typer.Option(
+        False, "-q", "--quiet", help="Disable additional logging."
+    ),
+):
+    """
+    Remove a student from the students list.
+    """
+
+    api = setup(quiet)
+    result = 0 if api.delete(student) else 1
+    sys.exit(result)
+
+
+@app.command()
+def holidays(
+    quiet: bool = typer.Option(
+        False, "-q", "--quiet", help="Disable additional logging."
+    ),
+):
+    """
+    School's out for summer! School's out forever! (removes all students)
+    """
+
+    api = setup(quiet)
+    students = api.get()
+
+    if not students:
+        if not quiet:
+            typer.echo("No students found!")
+        sys.exit(1)
+
+    result = 0 if all(api.delete(s) for s in students) else 1
+    if not quiet:
+        typer.echo(
+            [
+                f"Removed all {len(students)} students!",
+                f"Something went wrong, try again",
+            ][result]
+        )
+    sys.exit(result)

pythonanywhere/api/students_api.py

@@ -0,0 +1,52 @@
+"""Interface speaking with PythonAnywhere API providing methods for
+students.  *Don't use* `StudentsAPI` :class: in helper scripts, use
+`pythonanywhere.students.Students` class instead."""
+
+import getpass
+
+from pythonanywhere.api.base import call_api, get_api_endpoint
+
+
+class StudentsAPI:
+    """Interface for PythonAnywhere students API.
+
+    Uses `pythonanywhere.api.base` :method: `get_api_endpoint` to
+    create url, which is stored in a class variable `StudentsAPI.base_url`,
+    then calls `call_api` with appropriate arguments to execute student
+    action.
+
+    Covers:
+    - GET
+    - DELETE
+
+    Methods:
+    - use :method: `StudentsAPI.get` to get list of students
+    - use :method: `StudentsAPI.delete` to remove a student
+    """
+
+    base_url = get_api_endpoint().format(username=getpass.getuser(), flavor="students")
+
+    def get(self):
+        """Returns list of PythonAnywhere students related with user's account."""
+
+        result = call_api(self.base_url, "GET")
+
+        if result.status_code == 200:
+            return result.json()
+
+        raise Exception(f"GET to list students failed, got {result.text}")
+
+    def delete(self, student_username):
+        """Returns 204 if student has been successfully removed, raises otherwise."""
+
+        url = f"{self.base_url}{student_username}"
+
+        result = call_api(url, "DELETE")
+
+        if result.status_code == 204:
+            return result.status_code
+
+        detail = f": {result.text}" if result.text else ""
+        raise Exception(
+            f"DELETE to remove student {student_username!r} failed, got {result}{detail}"
+        )

pythonanywhere/api/students_api.pyi

@@ -0,0 +1,6 @@
+from typing import Dict, List
+
+class StudentsAPI:
+    base_url: str = ...
+    def get(self) -> Dict[str, List[Dict[str, str]]]: ...
+    def delete(self, params: dict) -> int: ...

pythonanywhere/students.py

@@ -0,0 +1,54 @@
+"""User interface for Pythonanywhere students API.
+
+Provides a class `Students` which should be used by helper scripts
+providing features for programmatic listing and removing of the user's
+students.
+"""
+
+import logging
+
+from pythonanywhere.api.students_api import StudentsAPI
+from pythonanywhere.snakesay import snakesay
+
+logger = logging.getLogger("pythonanywhere")
+
+
+class Students:
+    """Class providing interface for PythonAnywhere students API.
+
+    To perform actions on students related with user's account, use
+    following methods:
+    - :method:`Students.get` to get a list of students
+    - :method:`Students.delete` to remove a student with a given username
+    """
+
+    def __init__(self):
+        self.api = StudentsAPI()
+
+    def get(self):
+        """
+        Returns list of usernames when user has students, otherwise an
+        empty list.
+        """
+
+        try:
+            result = self.api.get()
+            student_usernames = [student["username"] for student in result["students"]]
+            logger.info(snakesay(f"{len(student_usernames)} students found!"))
+            return student_usernames
+        except Exception as e:
+            logger.warning(snakesay(str(e)))
+
+    def delete(self, username):
+        """
+        Returns `True` when user with `username` successfully removed from
+        user's students list, `False` otherwise.
+        """
+
+        try:
+            self.api.delete(username)
+            logger.info(snakesay(f"{username!r} removed from the students list!"))
+            return True
+        except Exception as e:
+            logger.warning(snakesay(str(e)))
+            return False

pythonanywhere/students.pyi

@@ -0,0 +1,8 @@
+from typing import Optional
+from pythonanywhere.api.students_api import Students_Api
+
+class Students:
+    api: StudentsAPI = ...
+    def __init__(self) -> None: ...
+    def get(self) -> Optional[list]: ...
+    def delete(self, username: str) -> bool: ...

tests/test_api_students.py

@@ -0,0 +1,65 @@
+import getpass
+import json
+
+import pytest
+import responses
+
+from pythonanywhere.api.base import get_api_endpoint
+from pythonanywhere.api.students_api import StudentsAPI
+
+
+@pytest.fixture
+def students_base_url():
+    return get_api_endpoint().format(username=getpass.getuser(), flavor="students")
+
+
+@pytest.mark.students
+class TestStudentsAPIGet:
+    def test_gets_list_of_students_when_there_are_some(
+        self, api_token, api_responses, students_base_url
+    ):
+        students = {
+            "students": [{"username": "student1"}, {"username": "student2"}]
+        }
+        api_responses.add(
+            responses.GET, url=students_base_url, status=200, body=json.dumps(students)
+        )
+
+        assert StudentsAPI().get() == students
+
+    def test_gets_empty_list_of_students_when_there_none(
+        self, api_token, api_responses, students_base_url
+    ):
+        students = {"students": []}
+        api_responses.add(
+            responses.GET, url=students_base_url, status=200, body=json.dumps(students)
+        )
+
+        assert StudentsAPI().get() == students
+
+
+@pytest.mark.students
+class TestStudentsAPIDelete:
+    def test_returns_204_when_student_deleted(
+        self, api_token, api_responses, students_base_url
+    ):
+        username = "byebye"
+        url = f"{students_base_url}{username}"
+        api_responses.add(responses.DELETE, url=url, status=204)
+
+        assert StudentsAPI().delete("byebye") == 204
+
+    def test_raises_with_404_when_no_student_to_delete_found(
+        self, api_token, api_responses, students_base_url
+    ):
+        username = "notyourstudent"
+        url = f"{students_base_url}{username}"
+        api_responses.add(responses.DELETE, url=url, status=404)
+
+        with pytest.raises(Exception) as e:
+            StudentsAPI().delete("notyourstudent")
+
+        expected_error_msg = (
+            f"DELETE to remove student {username!r} failed, got <Response [404]>"
+        )
+        assert str(e.value) == expected_error_msg