MagisterPy 0.1.0__py3-none-any.whl

MagisterPy/__init__.py

@@ -0,0 +1,4 @@
+from .magister_session import MagisterSession
+from .request_manager import LoginRequestsSender
+from .jsparser import *
+from .magister_errors import *

MagisterPy/error_handler.py

@@ -0,0 +1,27 @@
+import requests
+from .magister_errors import *
+def error_handler(func):
+    '''
+    A decorator used to handle errors that can occure when when executing the functions
+    '''
+    
+    def wrapper(*args, **kwargs):
+        _self = args[0]
+        try:
+            result = func(*args,**kwargs)
+            return result
+        except KeyboardInterrupt:
+            raise KeyboardInterrupt
+            
+        except requests.exceptions.ConnectionError as e:
+            _self._logMessage("Could not connect to Magister")
+            if _self.automatically_handle_errors:
+                pass
+            else:
+                raise ConnectionError()
+        except BaseMagisterError as e:
+            if _self.automatically_handle_errors:
+                _self._logMessage(e.message)
+            else:
+                raise e
+    return wrapper

MagisterPy/jsparser.py

@@ -0,0 +1,43 @@
+import json
+
+class JsParser():
+    def __init__(self):
+        pass
+    def get_authcode_from_js(self,js_content:str):
+        line = 1192
+        column = 15476
+        buffer = 200
+        authcode = ""
+        js_content = js_content.split("\n")[line][column:column+buffer]
+        start_list_index = None
+        content_list = [] #stores the 2 lists containing info about the authcode
+        
+        #Find the first and the second list
+        for idx, _char in enumerate(js_content):
+            
+            if _char == "[":
+                start_list_index = idx
+                
+            if _char == "]" and (not (start_list_index is None)):
+                
+                content_list.append(json.loads(js_content[start_list_index:idx+1]))
+            
+            if len(content_list)>1:
+                break
+        
+        if len(content_list) == 2:
+            convert_to_int = lambda a: int(a)
+
+            random_char_list, index_list = content_list
+
+            index_list = list(map(convert_to_int,index_list))
+
+            
+            for idx in index_list:
+                authcode+= random_char_list[idx]
+        if len(authcode) == 8:
+            return authcode
+        return None
+                
+
+        

MagisterPy/magister_errors.py

@@ -0,0 +1,23 @@
+class BaseMagisterError(Exception):
+    
+    def __init__(self, message=None):
+        super().__init__(message)
+        self.message = message
+
+
+class UnableToInputCredentials(BaseMagisterError):
+    
+    def __init__(self, message="\nCouldn't input the credentials\nThis error can occure if the credentials were not Input in order\nSchool->Username->Passwords"):
+        super().__init__(message)
+        self.message = message
+
+
+class IncorrectCredentials(BaseMagisterError):
+    def __init__(self, message="\nThe credentials provided were either incorrect or Magister rejected them"):
+        super().__init__(message)
+        self.message = message
+        
+class ConnectionError(BaseMagisterError):
+    def __init__(self, message="\nCould not connect to Magister. Please check your internet connection"):
+        super().__init__(message)
+        self.message = message

MagisterPy/magister_session.py

@@ -0,0 +1,342 @@
+import requests
+from urllib.parse import urlparse, parse_qs
+from .request_manager import LoginRequestsSender
+from typing import Optional
+from .error_handler import error_handler
+from .magister_errors import *
+
+class MagisterSession():
+    '''
+    Creates a session with Magister
+
+    Parameters:
+            enable_logging (bool):  Used to display errors in the standard output
+
+            automatically_handle_errors (bool): Used to automatically handle errors. If any function fails it returns None instead of raising an error
+    '''
+
+    def __init__(self, enable_logging = False, automatically_handle_errors = True):
+
+        self.request_sender = LoginRequestsSender()
+        self.session = requests.Session()
+        self.profile_auth_token = None #auth token for the redirect page
+        self.app_auth_token = None #auth token for the main app
+        self.authcode = None # gets randomly generated once every 3-7 days
+        self.sessionid = None # gets assigned when entering the login page
+        self.returnurl = None # used for some requests
+        self.main_payload = None #payload containing common parameters (authcode, returnurl, sessionid)
+        self.person_id = None # your account's person_id
+        self.account_id = None #your account id
+        self.api_url = None #url for accessing magister API
+        self.x_correlation_id = None #used in login requests
+        self.automatically_handle_errors = automatically_handle_errors
+
+        self.recieve_log = enable_logging
+    def _logMessage(self,msg:str):
+        if self.recieve_log:
+            print(msg)
+    
+
+    @error_handler
+    def input_school(self, school_name:str) ->Optional[requests.Response]:
+        '''
+        Sets up a session by inputting the school name. This is the **first step** in the login sequence 
+        and must be called before `input_username()` and `input_password()`.
+
+        Parameters:
+            school_name (str): The name of the school to authenticate against.
+
+        Usage:
+            This method is the **first step** of the login process. It must be called before 
+            `input_username()` and `input_password()` to initialize the session.
+
+        Returns:
+            requests.Response: if the school is found and session is successfully initiated.
+            None: if the school is not found or there’s an issue in the school lookup.
+
+        Example:
+            session.input_school("MySchoolName")
+        '''
+
+
+        #Initializing the login session
+        url_login_page = "https://accounts.magister.net/"
+
+        response = self.session.get(url_login_page,allow_redirects=False)
+
+        redirect_url_1 = r"https://accounts.magister.net/connect/authorize?client_id=iam-profile&redirect_uri=https%3A%2F%2Faccounts.magister.net%2Fprofile%2Foidc%2Fredirect_callback.html&response_type=id_token%20token&scope=openid%20profile%20email%20magister.iam.profile&state=57dcb9c3b667407791ff32a7af41e703&nonce=ec78d557c0e44751bf573db6719445cd"
+        response = self.session.get(redirect_url_1,allow_redirects=False)
+
+        
+        response = self.session.get(response.headers.get("location"), allow_redirects= False)
+        
+        response = self.session.get("https://accounts.magister.net/" + response.headers.get("location"), allow_redirects= False)
+        
+        self.sessionid = parse_qs(urlparse(response.url).query).get('sessionId', [None])[0]
+        self.returnurl = parse_qs(urlparse(response.url).query).get('returnUrl', [None])[0]
+        self.x_correlation_id = parse_qs(urlparse(self.returnurl).query).get('X-Correlation-ID', [None])[0]
+
+        javascript_redirect_url = self.request_sender.extract_redirect_url_from_html(response.text)
+        
+        
+        response = self.session.get(f"https://accounts.magister.net/{javascript_redirect_url}")
+        
+        self.authcode = self.request_sender.extract_dynamic_authcode(response.text)
+        
+        
+
+        self.main_payload = {
+        'authCode': self.authcode,
+        'returnUrl': self.returnurl, 
+        'sessionId': self.sessionid
+        }
+        #Inputting the credentials
+
+        #school
+        try:
+            response = self.request_sender.set_school(request_session=self.session,school_name=school_name,main_payload=self.main_payload)
+            if response.status_code !=200:
+                raise IncorrectCredentials(f"Could not find school: {school_name}")
+        except requests.exceptions.JSONDecodeError:
+            raise IncorrectCredentials(f"Could not find school: {school_name}")
+            
+        return response
+    @error_handler
+    def input_username(self,username:str) -> Optional[requests.Response]:
+        '''
+    Sets the username for the current session. This is the **second step** in the login sequence 
+    and must be called after `input_school()` but before `input_password()`.
+
+    Parameters:
+        username (str): The username for the account.
+
+    Usage:
+        This function must be called **after `input_school()`** and **before `input_password()`** to 
+        authenticate the username.
+
+    Returns:
+        requests.Response: if the username is accepted.
+        None: if the username is not found or if there’s an issue during authentication.
+
+    Example:
+        session.input_username("myusername")
+    '''
+
+        if not self.main_payload:
+            raise UnableToInputCredentials()
+        response = self.request_sender.set_username(request_session=self.session,username=username,main_payload=self.main_payload)
+        if response.status_code != 200:
+            raise IncorrectCredentials()
+            
+        
+        return response
+    @error_handler
+    def input_password(self,password:str) -> Optional[requests.Response]:
+        '''
+        Sets the password for the session and finalizes the login process. This is the **third and final step** 
+        in the login sequence and must be called after `input_school()` and `input_username()`.
+
+        Upon success, this method retrieves and stores essential session variables like `profile_auth_token`, 
+        `api_url`, `app_auth_token`, `account_id`, and `person_id` for further interactions with the API.
+
+        Parameters:
+            password (str): The password associated with the username.
+
+        Usage:
+            This function is the **final step** in the login process and should only be called **after 
+            `input_school()` and `input_username()`**.
+
+        Returns:
+            requests.Response: if the password is correct and login is successful.
+            None: if the password is incorrect or if there’s a login cooldown.
+
+        Example:
+            session.input_password("mypassword")
+        '''
+        if not self.main_payload:
+            raise UnableToInputCredentials()
+        response = self.request_sender.set_password(request_session=self.session,password=password,main_payload=self.main_payload)
+        if response.status_code !=200:
+            raise IncorrectCredentials("Incorrect password or the password input is on cooldown")
+            
+        #setup for variables
+        self.profile_auth_token = self.request_sender.get_profile_auth_token(request_session=self.session)
+        self.api_url = self.request_sender.get_api_url(request_session=self.session,profile_auth_token=self.profile_auth_token)
+        self.app_auth_token = self.request_sender.get_app_auth_token(request_session=self.session,api_url=self.api_url)
+        self.account_id = self.request_sender.get_accountid(request_session=self.session,app_auth_token=self.app_auth_token,api_url=self.api_url)
+        self.person_id = self.request_sender.get_personid(request_session=self.session,app_auth_token=self.app_auth_token,api_url=self.api_url,account_id=self.account_id)
+
+        self._logMessage("you have successfully logged in!")
+        return response
+    @error_handler
+    def login(self,school_name:str,username:str,password:str) -> bool:
+        '''
+        logs the user into their account
+
+        returns:
+        True -> if user logged in successfully
+        False -> if user wasn't able to login
+
+        params:
+        school_name -> a string of school name (not case sensitive. It sets the first school from the list that magister provides)
+        username -> a string of a username (should be exact)
+        password -> a string with the password of the user (should be exact)
+        '''
+        #Inputting the school
+        input_school_response = self.input_school(school_name=school_name)
+        
+        if not input_school_response:
+            return False
+            
+
+        #username
+        input_username_response = self.input_username(username=username)
+        if not input_username_response:
+            return False
+        #password
+        input_password_response = self.input_password(password=password)
+        if not input_password_response:
+            return False
+        
+        return True
+
+
+    @error_handler
+    def get_schedule(self, _from:str, to:str,with_changes = False) -> list[dict]:
+        '''
+    Retrieves the user’s schedule within a specified date range.
+    
+    This method fetches all scheduled items between two dates, starting from `_from` to `to`.
+    The session must be authenticated by calling `.login()` first.
+
+    Parameters:
+    - _from (str): Start date of the schedule period in "YYYY-MM-DD" format.
+    - to (str): End date of the schedule period in "YYYY-MM-DD" format.
+    - with_changes: Sends a different requests which retrieves recent changes. (It's not getting the changes on specific dates specifically so it's recomended to use with_changes = False instead)
+    Returns:
+    - list[dict]: A list of dictionaries representing schedule items, each with detailed fields. 
+      The schedule items are sorted chronologically from earliest to latest.
+
+    Structure of Each Schedule Item:
+    ```json
+    {
+        "Start": "datetime",                   # Start time of the scheduled item
+        "Einde": "datetime",                   # End time of the scheduled item
+        "LesuurVan": bool,                     # Boolean for lesson period start
+        "LesuurTotMet": bool,                  # Boolean for lesson period end
+        "DuurtHeleDag": bool,                  # Whether the event lasts all day
+        "Omschrijving": str,                   # Description of the event
+        "Lokatie": str,                        # Location of the event
+        "Status": int,                         # Status code of the event
+        "Type": int,                           # Type identifier of the event
+        "Subtype": int,                        # Subtype identifier of the event
+        "IsOnlineDeelname": bool,              # Whether online attendance is allowed
+        "WeergaveType": int,                   # Display type identifier
+        "Inhoud": str,                         # Content or details about the event
+        "Opmerking": str,                      # Additional notes
+        "InfoType": int,                       # Information type identifier
+        "Aantekening": str,                    # Notes or annotations
+        "Afgerond": bool,                      # Whether the event is completed
+        "HerhaalStatus": int,                  # Repeat status identifier
+        "Herhaling": None,                     # Repeat information (usually null)
+        "Vakken": list[dict],                  # List of subjects related to the event
+        "Docenten": list[dict],                # List of teachers associated with the event
+        "Lokalen": list[dict],                 # List of rooms assigned for the event
+        "Groepen": None,                       # Group information (usually null)
+        "OpdrachtId": int,                     # Task ID if associated
+        "HeeftBijlagen": bool,                 # Whether attachments are available
+        "Bijlagen": None                       # Attachment information (usually null)
+    }
+    ```
+
+    Example Usage:
+    ```python
+    session.get_schedule(_from="2024-11-10", to="2024-11-11")
+    ```
+    '''
+        if not self.app_auth_token:
+            self._logMessage("You have not logged in yet")
+            return
+        #Returns a schedule with no changes in it
+        remove_links_and_id = lambda a: {k: v for k, v in a.items() if k not in ["Links", "Id"]}
+        params = {
+            "status" : 1,
+            "tot": to,
+            "van": _from
+            }
+        headers = {"authorization":self.app_auth_token}
+        if not with_changes:
+            
+
+            
+            url = f"{self.api_url}/personen/{self.person_id}/afspraken"
+            respone = self.session.get(url=url,params=params,headers=headers)
+
+
+        else:
+            del params["status"]
+            url = f"{self.api_url}/personen/{self.person_id}/roosterwijzigingen"
+            respone = self.session.get(url=url,params=params,headers=headers)
+            
+        if respone.status_code == 200:
+
+            response_json = respone.json()["Items"]
+            return list(map(remove_links_and_id,response_json))
+    @error_handler
+    def get_grades(self, top:int = 25,skip:int = 0) -> list[dict]:
+        '''
+    Retrieves the most recent grades for the user.
+    
+    This method fetches the latest grades for the authenticated user.
+    The session must be authenticated by calling `.login()` first.
+
+    Parameters:
+    - top (int): Number of grades to retrieve (default is 25).
+    - skip (int): Number of grades to skip, for pagination (default is 0).
+
+    Returns:
+    - list[dict]: A list of dictionaries, each representing a grade item with relevant details. 
+      Grades are sorted from the most recent to the oldest.
+
+    Structure of Each Grade Item:
+    ```json
+    {
+        "omschrijving": str,                  # Description of the grade item
+        "ingevoerdOp": "datetime",            # Date when the grade was entered
+        "vak": {                              # Subject information
+            "code": str,                      # Subject code
+            "omschrijving": str               # Subject description
+        },
+        "waarde": str,                        # Grade value or score
+        "weegfactor": float,                  # Weight factor of the grade
+        "isVoldoende": bool,                  # Whether the grade is sufficient
+        "teltMee": bool,                      # Whether the grade counts in the final score
+        "moetInhalen": bool,                  # If the grade needs to be retaken
+        "heeftVrijstelling": bool,            # If the grade has an exemption
+        "behaaldOp": None,                    # Date achieved (if available)
+        "links": dict                         # Additional links or references (usually empty)
+    }
+    ```
+
+    Example Usage:
+    ```python
+    session.get_grades(top=1)
+    ```
+    '''
+        if not self.app_auth_token:
+            self._logMessage("You have not logged in yet")
+            return
+        remove_id = lambda a: {k: v for k, v in a.items() if k not in ["kolomId"]}
+        params = {
+        "top": top,
+        "skip": skip
+        }
+        headers = {"authorization":self.app_auth_token}
+        url = f"{self.api_url}/personen/{self.person_id}/cijfers/laatste"
+        respone = self.session.get(url=url,params=params,headers=headers)
+
+        if respone.status_code == 200:
+
+            response_json = respone.json()["items"]
+            return list(map(remove_id,response_json))
+        

MagisterPy/request_manager.py

@@ -0,0 +1,169 @@
+import requests
+from urllib.parse import urlparse, parse_qs
+from bs4 import BeautifulSoup
+from .jsparser import *
+from typing import Optional
+class LoginRequestsSender():
+    
+
+
+    def __init__(self):
+        pass
+
+    def get_subdomain(self,url):
+        
+        parsed_url = urlparse(url)
+        
+        
+        netloc = parsed_url.netloc
+        
+        
+        parts = netloc.split('.')
+        
+        
+        if len(parts) > 2:
+        
+            return '.'.join(parts[:-2])
+        else:
+            return None  
+
+
+    def get_accountid(self,request_session:requests.Session, app_auth_token,api_url) -> str:
+        url = f"{api_url}/sessions/current"
+        
+
+        headers = {
+            "authorization": app_auth_token
+        }
+        response = request_session.get(url, headers=headers,cookies=request_session.cookies)
+        if response.status_code == 200:
+            response_link = response.json()["links"]["account"]["href"]
+            account_id = response_link[response_link.rfind("/")+1:]
+            
+            return account_id
+
+    def get_personid(self,request_session:requests.Session, app_auth_token,api_url,account_id) -> str:
+        
+
+        url = f"{api_url}/accounts/{account_id}"
+        
+
+
+        headers = {
+            "authorization": app_auth_token
+        }
+
+        response = request_session.get(url=url,headers=headers)
+
+        if response.status_code == 200:
+            response_link =  response.json()["links"]["leerling"]["href"]
+            personid = response_link[response_link.rfind("/")+1:]
+            
+            return personid
+    def extract_auth_token(self,url) -> str:
+        # Parse the URL to get the fragment
+        parsed_url = urlparse(url)
+
+        fragment = parsed_url.fragment
+
+        # Parse the fragment to get the id_token
+        token_params = parse_qs(fragment)
+        id_token = token_params.get('access_token')
+
+        if id_token:
+            return id_token[0]  # Return the first id_token found
+        else:
+            return None
+    def get_profile_auth_token(self,request_session:requests.Session) -> str:
+        url = r"https://accounts.magister.net/connect/authorize?client_id=iam-profile&redirect_uri=https%3A%2F%2Faccounts.magister.net%2Fprofile%2Foidc%2Fredirect_callback.html&response_type=id_token%20token&scope=openid%20profile%20email%20magister.iam.profile&state=57dcb9c3b667407791ff32a7af41e703&nonce=ec78d557c0e44751bf573db6719445cd"
+        response = request_session.get(url,allow_redirects=False)
+        
+        url = response.headers["Location"]
+        return "Bearer " + self.extract_auth_token(url)
+
+
+    def get_app_auth_token(self,request_session:requests.Session,api_url) -> str:
+        url = "https://accounts.magister.net/connect/authorize"
+        subdomain = self.get_subdomain(api_url)
+        # Parameters as a dictionary
+        params = {
+            "client_id": f"M6-{subdomain}.magister.net",
+            "redirect_uri": f"https://{subdomain}.magister.net/oidc/redirect_callback.html",
+            "response_type": "id_token token",
+            "scope": "openid profile opp.read opp.manage attendance.overview attendance.administration "
+                    "calendar.user calendar.ical.user calendar.to-do.user grades.read grades.manage "
+                    "oso.administration registration.admin lockers.administration enrollment.admin",
+            "state": "57dcb9c3b667407791ff32a7af41e703",
+            "nonce": "ec78d557c0e44751bf573db6719445cd",
+            "acr_values": f"tenant:{subdomain}.magister.net"
+        }
+
+        response = request_session.get(url, params=params,allow_redirects=False)
+        url = response.headers["Location"]
+        return "Bearer " + self.extract_auth_token(url)
+
+        
+    def get_api_url(self,request_session:requests.Session,profile_auth_token) -> str:
+        headers = {"authorization": profile_auth_token}
+
+        response =  request_session.get("https://magister.net/.well-known/host-meta.json",headers=headers)
+        
+
+        items = response.json()
+        main_page = items["links"][0]["href"]
+        return main_page
+
+
+    def search_for_tenant_id(self,request_session:requests.Session,school_name,session_id) ->str :
+        response = request_session.get(f"https://accounts.magister.net/challenges/tenant/search?sessionId={session_id}&key={school_name}")
+        return response.json()[0]["id"]
+    def set_school(self,request_session:requests.Session,school_name,main_payload) ->requests.Response:
+
+        tenant_id = self.search_for_tenant_id(request_session,school_name, main_payload["sessionId"])
+        main_payload["tenant"] = tenant_id
+
+        response= self.send_post_request(request_session,main_payload,"https://accounts.magister.net/challenges/tenant")
+        return response
+
+    def set_password(self,request_session,password,main_payload) ->requests.Response:
+        main_payload["password"] = password
+        main_payload["userWantsToPairSoftToken"] = False
+        return self.send_post_request(request_session, main_payload,"https://accounts.magister.net/challenges/password")
+
+    def set_username(self,request_session,username,main_payload) -> requests.Response:
+        
+
+        main_payload["username"] = username
+        response = self.send_post_request(request_session,main_payload,"https://accounts.magister.net/challenges/username")
+        return response
+    def send_post_request(self,request_session:requests.Session,payload,url,auth_token = None) ->  requests.Response:
+
+        headers = {
+            "accept": "application/json",
+            "content-type": "application/json",
+            "authorization": auth_token,
+            "origin": "https://accounts.magister.net",
+            "x-xsrf-token": request_session.cookies.get("XSRF-TOKEN")
+        }
+
+        
+
+
+        response = request_session.post(url=url,json=payload,headers=headers, cookies=request_session.cookies)
+        return response
+    def extract_redirect_url_from_html(self,html_content:str) ->str:
+        soup = BeautifulSoup(html_content, 'html.parser')
+
+        # Find the script tag with defer attribute
+        script_tag = soup.find('script', {'defer': 'defer'})
+
+        # Extract the src attribute
+        if script_tag and 'src' in script_tag.attrs:
+            script_src = script_tag['src']
+            return script_src
+        else:
+            return None
+    def extract_dynamic_authcode(self,js_content):
+        return JsParser().get_authcode_from_js(js_content=js_content)
+    
+    

MagisterPy-0.1.0.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 H3LL0U
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

MagisterPy-0.1.0.dist-info/METADATA

@@ -0,0 +1,57 @@
+Metadata-Version: 2.1
+Name: MagisterPy
+Version: 0.1.0
+Summary: A Python package for retrieving information from magister
+Home-page: https://github.com/H3LL0U/MagisterPy
+Author: H3LL0U
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: beautifulsoup4==4.12.3
+Requires-Dist: certifi==2024.8.30
+Requires-Dist: charset-normalizer==3.4.0
+Requires-Dist: idna==3.10
+Requires-Dist: requests==2.32.3
+Requires-Dist: soupsieve==2.6
+Requires-Dist: urllib3==2.2.3
+
+# MagisterPY
+
+This library will help you interact with your magister account using python!
+
+## Disclaimer: 
+Please note: Using unauthorized APIs to access Magister is against Magister’s Terms of Service. 
+By using this library, you assume all responsibility and accept any risks associated with breaching these terms. 
+For more details, please refer to Magister's Terms of Service. (https://magister.nl/over-ons/juridische-zaken/)
+
+## Installation
+```
+pip install git+https://github.com/H3LL0U/MagisterPy.git
+```
+
+## Contributing
+Feel free to create an issue if something doesn't work. It's only been tested on a singular school so far so it is to be expected. If you want to help add a feature it would be great as well! :D
+
+## Basic usage
+The following code snippet demonstrates how to create a session, log in, and retrieve your schedule and recent grades:
+```
+from magisterpy import MagisterSession
+
+# Create a new session and log in
+session = MagisterSession()
+session.login(school_name="School_name", username="your_username", password="your_password")
+
+# Get schedule for a specific date range
+my_schedule = session.get_schedule("2024-11-03", "2024-11-10")
+
+# Get the most recent grade
+my_most_recent_grade = session.get_grades(top=1)[0]["waarde"]
+
+print("Schedule:", my_schedule)
+print("Most Recent Grade:", my_most_recent_grade)
+```
+With MagisterPy, you can access and manage your Magister account directly from Python, automating repetitive tasks and integrating your school data into your projects. We hope you find it helpful!
+More functionality to come!

MagisterPy-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+MagisterPy/__init__.py,sha256=pBqUptTl7dfnWfMw3LSyzfLF3YELq25SGxtVt9oe4OI,152
+MagisterPy/error_handler.py,sha256=CnK60mfbn6VtFG4wD5Nt7afFMkSfqawYRl15ZM5RpWw,872
+MagisterPy/jsparser.py,sha256=IkRqD_NcwXTE7CgeNP2OKpUOmnm2cLvEXYuFVYpPrpo,1283
+MagisterPy/magister_errors.py,sha256=jFXMc1dSwMep6JYMx4ZdsmQRzTSuW3mdIhSfToZ0eQY,897
+MagisterPy/magister_session.py,sha256=mFIDwNcYWS9dU0Qfw3IBzZjQKVKkpK1Jx0wWFiBDNG4,15829
+MagisterPy/request_manager.py,sha256=V5lIgs1GoLMoCMx-qEOVmIS5W6klWX8YqJ9ugnsbkqo,6697
+MagisterPy-0.1.0.dist-info/LICENSE,sha256=beoj0kwBYTN1yTItpASt3XIMGW0KX4rcbJOVpy2mZ6c,1084
+MagisterPy-0.1.0.dist-info/METADATA,sha256=0pLOSEu9ojJw7phtlWx7SzON0QF1Jaxyp1IW0zJ40c4,2278
+MagisterPy-0.1.0.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+MagisterPy-0.1.0.dist-info/top_level.txt,sha256=-8fWbu8ze-lHyvaI77aZo1gQkd8KNU5vvZBPkLLum-4,11
+MagisterPy-0.1.0.dist-info/RECORD,,

MagisterPy-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.6.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

MagisterPy-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+MagisterPy