esprit-py 0.5.0__py3-none-any.whl

esprit/__init__.py

@@ -0,0 +1 @@
+from .esprit import Esprit

esprit/absence.py

@@ -0,0 +1,52 @@
+from bs4 import BeautifulSoup
+
+
+class Absence:
+    """
+    A class used to represent an Absence.
+
+    ...
+
+    Attributes
+    ----------
+    url : str
+        a formatted string that represents the URL of the absence page
+    session : requests.Session
+        a Session object from the requests library
+
+    Methods
+    -------
+    get_absences():
+        Returns a list of absences for the student.
+    """
+
+    def __init__(self, session):
+        self.url = "https://esprit-tn.com/ESPOnline/Etudiants/absenceetud.aspx"
+        self.session = session
+
+    def get_absences(self):
+        """
+        Returns a list of absences for the student.
+
+        Returns
+        -------
+        list
+            a list of absences, each represented as a list of strings. The first list is the headers.
+            Returns None if the page does not contain the expected text.
+        """
+
+        response = self.session.get(self.url)
+        soup = BeautifulSoup(response.text, 'html.parser')
+
+        # Check if the <strong> tag with the text "Absence" exists
+        strong_tag = soup.find('strong', text='Absence')
+        if strong_tag is None:
+            print("The page does not contain the expected text.")
+            return None
+
+        table = soup.find('table', {'id': 'ContentPlaceHolder1_GridView2'})
+        rows = table.find_all('tr')
+        headers = [cell.text.strip() for cell in rows[0].find_all('th')]
+        absences = [headers] + [[cell.text.strip() for cell in row.find_all('td')]
+                                for row in rows[1:]]  # Skip header row
+        return absences

esprit/auth.py

@@ -0,0 +1,432 @@
+import requests
+from bs4 import BeautifulSoup
+
+
+class Auth:
+    """
+    A class used to represent an Authentication process
+
+    ...
+
+    Attributes
+    ----------
+    login_url : str
+        a string representing the login URL
+    debug : bool
+        a boolean indicating if debug mode is on
+    session : requests.Session
+        a requests Session object to maintain cookies and state
+
+    Methods
+    -------
+    login(id, password)
+        Logs in to the website using the provided id and password
+    """
+
+    def __init__(self, driver_path=None, driver=None, debug=False, headless=True):
+        """
+        Constructs all the necessary attributes for the Auth object.
+
+        Parameters
+        ----------
+            driver_path : str, optional
+                Path to the WebDriver executable (deprecated, kept for compatibility)
+            driver : WebDriver, optional
+                Existing WebDriver instance (deprecated, kept for compatibility)
+            debug : bool, optional
+                Debug mode flag (default is False)
+            headless : bool, optional
+                Headless mode flag (deprecated, kept for compatibility)
+        """
+
+        self.login_url = "https://esprit-tn.com/esponline/online/default.aspx"
+        self.home_url = "https://esprit-tn.com/esponline/Etudiants/Accueil.aspx"
+        self.logout_urls = [
+            "https://esprit-tn.com/esponline/Etudiants/Deconnexion.aspx",
+            "https://esprit-tn.com/esponline/online/Deconnexion.aspx",
+        ]
+        self.debug = debug
+        self.session = requests.Session()
+        # Set user agent to mimic a real browser
+        self.session.headers.update({
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36'
+        })
+
+    def _extract_viewstate(self, html):
+        """Extract ASP.NET ViewState and EventValidation from HTML"""
+        soup = BeautifulSoup(html, 'html.parser')
+        viewstate = soup.find('input', {'id': '__VIEWSTATE'})
+        viewstate_generator = soup.find('input', {'id': '__VIEWSTATEGENERATOR'})
+        event_validation = soup.find('input', {'id': '__EVENTVALIDATION'})
+        
+        data = {}
+        if viewstate:
+            data['__VIEWSTATE'] = viewstate.get('value', '')
+        if viewstate_generator:
+            data['__VIEWSTATEGENERATOR'] = viewstate_generator.get('value', '')
+        if event_validation:
+            data['__EVENTVALIDATION'] = event_validation.get('value', '')
+        
+        return data
+
+    def login(self, id, password):
+        """
+        Logs in to the website using the provided id and password.
+
+        Parameters
+        ----------
+            id : str
+                User's id
+            password : str
+                User's password
+
+        Returns
+        -------
+        list
+            List of cookies if login is successful, None otherwise
+        """
+
+        # Step 1: Get the initial login page
+        response = self.session.get(self.login_url)
+        if response.status_code != 200:
+            print('Failed to load login page')
+            return None
+        
+        # Extract ViewState and EventValidation
+        form_data = self._extract_viewstate(response.text)
+        
+        # Step 2: Find the ID input field and checkbox on initial page
+        soup = BeautifulSoup(response.text, 'html.parser')
+        # Try to find ID field by various methods
+        id_input = (soup.find('input', {'id': lambda x: x and 'textbox3' in x.lower()}) or
+                   soup.find('input', {'id': lambda x: x and 'textbox1' in x.lower()}) or
+                   soup.find('input', {'type': 'text', 'id': lambda x: x and 'textbox' in x.lower()}))
+        id_field_name = None
+        if id_input:
+            id_field_name = id_input.get('name') or id_input.get('id', '')
+            if self.debug:
+                print(f'Found ID field: id={id_input.get("id")}, name={id_field_name}')
+        
+        # Find the checkbox on the initial page (before clicking Suivant)
+        checkbox = soup.find('input', {'type': 'checkbox'})
+        checkbox_name = None
+        if checkbox:
+            checkbox_name = checkbox.get('name') or checkbox.get('id', '')
+            if self.debug:
+                print(f'Found checkbox on initial page: id={checkbox.get("id")}, name={checkbox_name}')
+        
+        # Use dynamic name if found, otherwise try both with and without ctl00$ prefix
+        if id_field_name:
+            form_data[id_field_name] = id
+        else:
+            form_data['ctl00$ContentPlaceHolder1$TextBox3'] = id
+            form_data['ContentPlaceHolder1$TextBox3'] = id
+        
+        # First, check the checkbox to reveal continue button
+        if checkbox_name:
+            form_data_checkbox = self._extract_viewstate(response.text)
+            form_data_checkbox[id_field_name] = id
+            form_data_checkbox[checkbox_name] = 'on'
+            form_data_checkbox['__EVENTTARGET'] = checkbox_name
+            form_data_checkbox['__EVENTARGUMENT'] = ''
+            
+            if self.debug:
+                print('Checking checkbox to reveal continue button...')
+            
+            response_checkbox = self.session.post(self.login_url, data=form_data_checkbox)
+            if response_checkbox.status_code == 200:
+                # Check if continue button appeared
+                soup_checkbox = BeautifulSoup(response_checkbox.text, 'html.parser')
+                continue_button = (soup_checkbox.find('input', {'type': 'submit', 'value': lambda x: x and ('continuer' in x.lower() or 'continue' in x.lower())}) or
+                                 soup_checkbox.find('input', {'type': 'button', 'value': lambda x: x and ('continuer' in x.lower() or 'continue' in x.lower())}) or
+                                 soup_checkbox.find('button', string=lambda x: x and ('continuer' in x.lower() or 'continue' in x.lower())))
+                
+                # Debug: Check all buttons on the page after checking checkbox
+                all_buttons = soup_checkbox.find_all('input', {'type': ['submit', 'button']})
+                if self.debug:
+                    print(f'Found {len(all_buttons)} buttons on page after checking checkbox')
+                    for btn in all_buttons:
+                        btn_id = btn.get('id', '')
+                        btn_name = btn.get('name', '')
+                        btn_value = btn.get('value', '')
+                        print(f'  Button: id={btn_id}, name={btn_name}, value={btn_value}')
+                
+                if continue_button:
+                    if self.debug:
+                        print('Continue button appeared, clicking it...')
+                    # Click continue button
+                    form_data_continue = self._extract_viewstate(response_checkbox.text)
+                    form_data_continue[id_field_name] = id
+                    form_data_continue[checkbox_name] = 'on'
+                    continue_button_name = continue_button.get('name') or continue_button.get('id', '')
+                    form_data_continue['__EVENTTARGET'] = continue_button_name
+                    form_data_continue['__EVENTARGUMENT'] = ''
+                    
+                    response_continue = self.session.post(self.login_url, data=form_data_continue)
+                    if response_continue.status_code == 200:
+                        response = response_continue
+                        form_data = self._extract_viewstate(response_continue.text)
+                        form_data[id_field_name] = id
+                        form_data[checkbox_name] = 'on'
+                    else:
+                        response = response_checkbox
+                        form_data = self._extract_viewstate(response_checkbox.text)
+                        form_data[id_field_name] = id
+                        form_data[checkbox_name] = 'on'
+                else:
+                    # No continue button found by text, but maybe it's the Suivant button that's now enabled?
+                    # Or maybe we can proceed directly with Suivant
+                    if self.debug:
+                        print('Continue button not found, proceeding with Suivant')
+                    response = response_checkbox
+                    form_data = self._extract_viewstate(response_checkbox.text)
+                    form_data[id_field_name] = id
+                    form_data[checkbox_name] = 'on'
+            else:
+                # If checkbox interaction fails, proceed normally
+                if self.debug:
+                    print('Checkbox interaction failed, proceeding normally')
+                form_data[id_field_name] = id
+        
+        # Find the Suivant button dynamically
+        # After checking checkbox, Button3 becomes visible (Button1 is hidden)
+        soup_current = BeautifulSoup(response.text, 'html.parser')
+        suivant_button = (soup_current.find('input', {'id': lambda x: x and 'button3' in x.lower()}) or
+                         soup_current.find('input', {'name': lambda x: x and 'button3' in x.lower()}) or
+                         soup_current.find('input', {'type': 'submit', 'value': lambda x: x and ('suivant' in x.lower() or 'next' in x.lower())}) or
+                         soup_current.find('input', {'id': lambda x: x and 'button1' in x.lower()}) or
+                         soup_current.find('input', {'name': lambda x: x and 'button1' in x.lower()}))
+        
+        if suivant_button:
+            button_name = suivant_button.get('name') or suivant_button.get('id', '')
+            if button_name:
+                form_data['__EVENTTARGET'] = button_name
+                if self.debug:
+                    print(f'Found suivant button: {button_name}')
+        else:
+            # Fall back to Button3 (after checkbox) or Button1
+            form_data['__EVENTTARGET'] = 'ctl00$ContentPlaceHolder1$Button3'
+            if self.debug:
+                print('Using default suivant button name (Button3)')
+        
+        form_data['__EVENTARGUMENT'] = ''
+        
+        # Step 3: Submit the ID with checkbox checked (click 'Suivant' button)
+        response = self.session.post(self.login_url, data=form_data)
+        if response.status_code != 200:
+            print('Failed to submit ID')
+            return None
+        
+        if self.debug:
+            print('After submitting ID with checkbox checked, now on password page...')
+        
+        # Step 4: Extract ViewState again after clicking Suivant (now on password page)
+        form_data = self._extract_viewstate(response.text)
+        
+        # Step 5: Submit the password (click 'Connexion' button)
+        # Use the latest response (after continue button click)
+        # Re-parse the latest response to find password field
+        soup = BeautifulSoup(response.text, 'html.parser')
+        
+        if self.debug:
+            # Check what's on the current page
+            all_inputs = soup.find_all('input')
+            print(f'Current page has {len(all_inputs)} input fields')
+            for inp in all_inputs:
+                inp_type = inp.get('type', '')
+                inp_id = inp.get('id', '')
+                inp_name = inp.get('name', '')
+                inp_value = inp.get('value', '')
+                if inp_type == 'password' or 'password' in inp_id.lower() or 'password' in inp_name.lower():
+                    print(f'  Password input: id={inp_id}, name={inp_name}, type={inp_type}, disabled={inp.get("disabled")}')
+                elif inp_type == 'text':
+                    print(f'  Text input: id={inp_id}, name={inp_name}, value={inp_value[:30] if inp_value else ""}')
+                elif inp_type == 'hidden':
+                    print(f'  Hidden input: id={inp_id}, name={inp_name}, value={inp_value[:30] if inp_value else ""}')
+                elif inp_type in ['submit', 'button']:
+                    print(f'  Button: id={inp_id}, name={inp_name}, value={inp_value}')
+        
+        # Find password field for student (TextBox7, not TextBox2!)
+        password_input = (soup.find('input', {'id': lambda x: x and 'textbox7' in x.lower()}) or
+                         soup.find('input', {'name': lambda x: x and 'textbox7' in x.lower()}) or
+                         soup.find('input', {'type': 'password'}))
+        password_field_name = None
+        if password_input:
+            password_field_name = password_input.get('name') or password_input.get('id', '')
+            if self.debug:
+                print(f'Found password field: {password_field_name}')
+                # Check if it's disabled
+                if password_input.get('disabled'):
+                    print('WARNING: Password field is disabled!')
+        
+        # Use dynamic name if found, otherwise fall back to default
+        if password_field_name:
+            form_data[password_field_name] = password
+        else:
+            # Try both with and without ctl00$ prefix
+            form_data['ctl00$ContentPlaceHolder1$TextBox7'] = password
+            form_data['ContentPlaceHolder1$TextBox7'] = password
+        
+        # DO NOT include ID or checkbox - they don't exist on the password page after Suivant!
+        
+        # Find the connection button for student (ButtonEtudiant, not Button2!)
+        connexion_button = (soup.find('input', {'id': lambda x: x and 'buttonetudiant' in x.lower()}) or
+                          soup.find('input', {'name': lambda x: x and 'buttonetudiant' in x.lower()}) or
+                          soup.find('input', {'type': 'submit', 'value': lambda x: x and ('connexion' in x.lower() or 'connect' in x.lower())}) or
+                          soup.find('input', {'id': lambda x: x and 'button2' in x.lower()}) or
+                          soup.find('input', {'name': lambda x: x and 'button2' in x.lower()}))
+        
+        if connexion_button:
+            button_name = connexion_button.get('name') or connexion_button.get('id', '')
+            if button_name:
+                # For ASP.NET, use __EVENTTARGET with the button name
+                form_data['__EVENTTARGET'] = button_name
+                form_data['__EVENTARGUMENT'] = ''
+                if self.debug:
+                    print(f'Found connexion button: {button_name}, using __EVENTTARGET')
+        else:
+            # Fall back to default (ButtonEtudiant for student login)
+            form_data['__EVENTTARGET'] = 'ctl00$ContentPlaceHolder1$ButtonEtudiant'
+            form_data['__EVENTARGUMENT'] = ''
+            if self.debug:
+                print('Using default connexion button name (ButtonEtudiant)')
+        
+        if self.debug:
+            print('Submitting password (without ID or checkbox)')
+        
+        if self.debug:
+            print(f'Submitting password with form data keys: {list(form_data.keys())}')
+        
+        # Use the current page URL (password page) instead of login URL
+        current_url = response.url if hasattr(response, 'url') else self.login_url
+        if self.debug:
+            print(f'Posting to URL: {current_url}')
+        
+        response = self.session.post(current_url, data=form_data, allow_redirects=True)
+        
+        if self.debug:
+            print(f'After password submission:')
+            print(f'  Status code: {response.status_code}')
+            print(f'  Final URL: {response.url}')
+            print(f'  Redirected: {response.url != self.login_url}')
+            
+            # Check what's in the response
+            if 'error' in response.text.lower() or 'erreur' in response.text.lower():
+                print('Response contains error/erreur')
+            if 'invalid' in response.text.lower() or 'invalide' in response.text.lower():
+                print('Response contains invalid/invalide')
+        
+        # Check if login was successful
+        # After successful login, we should be redirected to Accueil.aspx (home page)
+        # Check if we're on the login page (default.aspx) or home page (Accueil.aspx)
+        is_on_login_page = 'default.aspx' in response.url.lower()
+        is_on_home_page = 'accueil.aspx' in response.url.lower() or 'Accueil.aspx' in response.url
+        
+        # Look for multiple success indicators
+        success_indicators = [
+            'Vous pouvez consulter dans cet espace :',
+            'Espace Etudiant',
+            'Accueil.aspx',
+            'Label2',  # Student name label
+            'Label3'   # Student class label
+        ]
+        
+        login_successful = (not is_on_login_page) and (is_on_home_page or any(indicator in response.text for indicator in success_indicators))
+        
+        if self.debug:
+            print(f'Checking login success...')
+            print(f'  On login page: {is_on_login_page}')
+            print(f'  On home page: {is_on_home_page}')
+            for indicator in success_indicators:
+                if indicator in response.text:
+                    print(f'  Found success indicator: {indicator}')
+        
+        if login_successful:
+            print('''
+                  -----------------
+                  Login successful!
+                  -----------------
+                  ''')
+            # Convert requests cookies to Selenium-like format for compatibility
+            cookies = []
+            for cookie in self.session.cookies:
+                cookies.append({
+                    'name': cookie.name,
+                    'value': cookie.value,
+                    'domain': cookie.domain,
+                    'path': cookie.path
+                })
+            return cookies
+        else:
+            print('''
+                  -------------
+                  Login failed!
+                  -------------
+                  ''')
+            return None
+    
+    def logout(self):
+        """
+        Logout from the ESPRIT website.
+        
+        Returns:
+            bool: True if logout was successful, False otherwise.
+        """
+        if self.debug:
+            print('Starting logout...')
+        
+        # Method 1: Try ASP.NET postback mechanism
+        try:
+            # Get the home page to retrieve ViewState
+            response = self.session.get(self.home_url, allow_redirects=True)
+            
+            if response.status_code == 200 and 'default.aspx' not in response.url.lower():
+                # We're logged in, now perform logout postback
+                soup = BeautifulSoup(response.text, 'html.parser')
+                
+                # Extract ViewState for the postback
+                form_data = self._extract_viewstate(response.text)
+                
+                # Set up the postback to trigger LinkButton1 (logout button)
+                form_data['__EVENTTARGET'] = 'ctl00$LinkButton1'
+                form_data['__EVENTARGUMENT'] = ''
+                
+                if self.debug:
+                    print('Sending logout postback...')
+                
+                # Submit the logout postback
+                logout_response = self.session.post(self.home_url, data=form_data, allow_redirects=True)
+                
+                # Check if we're redirected to login page
+                if 'default.aspx' in logout_response.url or logout_response.status_code == 200:
+                    if self.debug:
+                        print('Logout successful (postback method)')
+                    return True
+        except Exception as e:
+            if self.debug:
+                print(f'Postback logout failed: {e}')
+        
+        # Method 2: Try direct logout URLs
+        for logout_url in self.logout_urls:
+            try:
+                if self.debug:
+                    print(f'Trying logout URL: {logout_url}')
+                
+                response = self.session.get(logout_url, allow_redirects=True)
+                
+                # Check if redirected to login page or session cleared
+                if 'default.aspx' in response.url or response.status_code == 200:
+                    if self.debug:
+                        print(f'Logout successful via URL: {logout_url}')
+                    return True
+            except Exception as e:
+                if self.debug:
+                    print(f'Logout URL {logout_url} failed: {e}')
+                continue
+        
+        # Method 3: Clear session cookies as fallback
+        if self.debug:
+            print('Clearing session cookies...')
+        self.session.cookies.clear()
+        
+        return True

esprit/credit.py

@@ -0,0 +1,91 @@
+from bs4 import BeautifulSoup
+
+
+class Credit:
+    """
+    A class used to represent a Credit.
+
+    ...
+
+    Attributes
+    ----------
+    url : str
+        a formatted string that represents the URL of the credit page
+    session : requests.Session
+        a Session object from the requests library
+
+    Methods
+    -------
+    get_credits():
+        Returns a list of credits for the student.
+    """
+
+    def __init__(self, session):
+        self.url = "https://esprit-tn.com/ESPOnline/Etudiants/Historique_Cr%C3%A9dit.aspx"
+        self.session = session
+
+    def get_credits(self):
+        """
+        Returns a list of credits for the student.
+
+        Returns
+        -------
+        list
+            a list of credits, each represented as a list of strings. The first list is the headers.
+            Returns None if the page does not contain the expected text.
+        """
+        response = self.session.get(self.url, allow_redirects=False)
+        if response.status_code == 302 or response.status_code == 301:
+            # Follow redirect
+            response = self.session.get(self.url, allow_redirects=True)
+        
+        if response.status_code != 200:
+            print("Failed to load credits page.")
+            return None
+        
+        # Check if we were redirected to login page
+        if 'default.aspx' in response.url or 'login' in response.url.lower():
+            print("Session expired or invalid - redirected to login page.")
+            return None
+        
+        soup = BeautifulSoup(response.text, 'html.parser')
+
+        # Find the table with id='ContentPlaceHolder1_GridView1'
+        table = soup.find('table', {'id': 'ContentPlaceHolder1_GridView1'})
+        if table is None:
+            # Try to find table by structure (has headers like "Année universitaire")
+            all_tables = soup.find_all('table')
+            for tbl in all_tables:
+                rows = tbl.find_all('tr')
+                if len(rows) > 0:
+                    first_row = rows[0]
+                    ths = first_row.find_all('th')
+                    if len(ths) > 0:
+                        headers = [th.text.strip() for th in ths]
+                        if 'Année universitaire' in headers or 'Unité d\'enseignement' in headers:
+                            table = tbl
+                            break
+            
+            if table is None:
+                print("Credits table not found on page.")
+                return None
+
+        rows = table.find_all('tr')
+        if len(rows) == 0:
+            print("No rows found in credits table.")
+            return None
+        
+        # Extract headers from first row
+        headers = [cell.text.strip() for cell in rows[0].find_all('th')]
+        if len(headers) == 0:
+            print("No headers found in credits table.")
+            return None
+        
+        # Extract data rows
+        credits = [headers]
+        for row in rows[1:]:  # Skip header row
+            cells = [cell.text.strip() for cell in row.find_all('td')]
+            if len(cells) > 0:
+                credits.append(cells)
+        
+        return credits

esprit/esprit.py

@@ -0,0 +1,66 @@
+import requests
+from .auth import Auth
+from .grade import Grade
+from .absence import Absence
+from .time_schedule import TimeSchedule
+from .credit import Credit
+from .utils import Utils
+# from .exceptions import EspritException #TODO
+
+
+class Esprit:
+    def __init__(self, driver_path=None, driver=None, debug=False, headless=True):
+        self.auth = Auth(driver_path, driver, debug, headless)
+        # Use the same session from Auth to maintain cookies
+        self.session = self.auth.session
+        self.grade_scrape = Grade(self.session)
+        self.absence_scrape = Absence(self.session)
+        self.time_schedule_scrape = TimeSchedule(self.session)
+        self.credit = Credit(self.session)
+        self.utils = Utils(self.session)
+
+    def login(self, username, password):
+        cookies = self.auth.login(username, password)
+        # Session is already updated in Auth, so we just need to check if login was successful
+        if cookies is None:
+            return False
+        return True
+    
+    def logout(self):
+        """
+        Logout from the ESPRIT website.
+        
+        Returns:
+            bool: True if logout was successful, False otherwise.
+        """
+        return self.auth.logout()
+
+    def get_grades(self):
+        return self.grade_scrape.get_grades()
+
+    def calculate_average(self, grades):
+        return self.grade_scrape.calculate_average(grades)
+
+    def get_absences(self):
+        return self.absence_scrape.get_absences()
+
+    def get_table_schedules(self):
+        return self.time_schedule_scrape.get_table_schedules()
+
+    def get_last_week_schedule(self):
+        return self.time_schedule_scrape.get_last_week_schedule()
+
+    def download_files(self, schedule, download_path):
+        return self.time_schedule_scrape.download_files(schedule, download_path)
+
+    def get_class_week_schedule(self, file_path, class_name, result_path):
+        return self.time_schedule_scrape.get_class_week_schedule(file_path, class_name, result_path)
+
+    def get_credits(self):
+        return self.credit.get_credits()
+
+    def get_student_name(self):
+        return self.utils.get_student_name()
+
+    def get_student_class(self):
+        return self.utils.get_student_class()

esprit/grade.py

@@ -0,0 +1,102 @@
+from bs4 import BeautifulSoup
+import pandas as pd
+import numpy as np
+
+
+class Grade:
+    """
+    A class used to represent a Grade.
+
+    ...
+
+    Attributes
+    ----------
+    url : str
+        a formatted string that represents the URL of the grade page
+    session : requests.Session
+        a Session object from the requests library
+
+    Methods
+    -------
+    get_grades():
+        Returns a list of grades for the student.
+    calculate_average(grades):
+        Calculate the average grade based on the given grades.
+    """
+
+    def __init__(self, session):
+        self.url = "https://esprit-tn.com/ESPOnline/Etudiants/Resultat2021.aspx"
+        self.session = session
+
+    def get_grades(self):
+        """
+        Returns a list of grades for the student.
+
+        Returns
+        -------
+        list
+            a list of grades, each represented as a list of strings. The first list is the headers.
+            Returns None if the page does not contain the expected text.
+        """
+        response = self.session.get(self.url)
+        soup = BeautifulSoup(response.text, 'html.parser')
+
+        # Check if the <h1> tag with the text "Notes Des Modules" exists
+        h1_tag = soup.find('h1', text=' Notes Des Modules ')
+        if h1_tag is None:
+            print("The page does not contain the expected text.")
+            return None
+
+        table = soup.find('table', {'id': 'ContentPlaceHolder1_GridView1'})
+        rows = table.find_all('tr')
+        headers = [cell.text.strip() for cell in rows[0].find_all('th')]
+        grades = [headers] + [[cell.text.strip() for cell in row.find_all('td')]
+                              for row in rows[1:]]  # Skip header row
+        return grades
+
+    def calculate_average(self, grades):
+        """
+        Calculate the average grade based on the given grades.
+
+        Parameters
+        ----------
+        grades (list): A list of lists representing the grades. The first list should contain the column names.
+
+        Returns
+        -------
+        float: The calculated average grade.
+        """
+        # Convert the list of lists to a DataFrame
+        df = pd.DataFrame(grades[1:], columns=grades[0])
+
+        # Replace empty strings with NaN
+        df.replace('', np.nan, inplace=True)
+
+        # Replace comma with dot and convert to float
+        for col in ['COEF', 'NOTE_CC', 'NOTE_TP', 'NOTE_EXAM']:
+            df[col] = df[col].str.replace(',', '.').astype(float)
+
+        # Calculate the average based on available grades
+
+        def calculate_average(row):
+            if pd.isna(row['NOTE_TP']):
+                if pd.isna(row['NOTE_CC']):
+                    return row['NOTE_EXAM']
+                else:
+                    return row['NOTE_EXAM'] * 0.6 + row['NOTE_CC'] * 0.4
+            elif pd.isna(row['NOTE_CC']):
+                return row['NOTE_EXAM'] * 0.8 + row['NOTE_TP'] * 0.2
+            else:
+                return row['NOTE_EXAM'] * 0.5 + row['NOTE_CC'] * 0.3 + row['NOTE_TP'] * 0.2
+
+        df['MOYENNE'] = df.apply(calculate_average, axis=1)
+
+        # Calculate the total average
+        total_average = (df['MOYENNE'] * df['COEF']).sum() / df['COEF'].sum()
+
+        # Append the total average to the DataFrame
+        df = df._append({'DESIGNATION': 'Moyenne', 'COEF': df['COEF'].sum(
+        ), 'MOYENNE': total_average}, ignore_index=True)
+
+        print(df)
+        return total_average

esprit/time_schedule.py

@@ -0,0 +1,185 @@
+from bs4 import BeautifulSoup
+from datetime import datetime
+import re
+import os
+from PyPDF2 import PdfReader, PdfWriter
+
+
+class TimeSchedule:
+    """
+    A class used to represent a Time Schedule.
+
+    ...
+
+    Attributes
+    ----------
+    url : str
+        a formatted string that represents the URL of the time schedule page
+    session : requests.Session
+        a Session object from the requests library
+
+    Methods
+    -------
+    get_table_schedules():
+        Returns a list of time schedules for the student.
+    get_last_week_schedule():
+        Returns the most recent weekly schedule.
+    download_files(schedule: list):
+        Downloads the files associated with a given schedule.
+    get_class_week_schedule(file_path: str, class_name: str):
+        Extracts the weekly schedule for a specific class from a given file.
+    """
+
+    def __init__(self, session):
+        self.url = "https://esprit-tn.com/ESPOnline/Etudiants/Emplois.aspx"
+        self.session = session
+
+    def get_table_schedules(self):
+        """
+        Returns a list of time schedules for the student.
+
+        Returns
+        -------
+        list
+            a list of time schedules, each represented as a list of strings.
+            Returns None if the page does not contain the expected text.
+        """
+        response = self.session.get(self.url)
+        soup = BeautifulSoup(response.text, 'html.parser')
+
+        # Check if the <strong> tag with the text "Emploi du temps" exists
+        strong_tag = soup.find('strong', text='Emploi du temps')
+        if strong_tag is None:
+            print("The page does not contain the expected text.")
+            return None
+
+        table = soup.find('table', {'id': 'ContentPlaceHolder1_GridView1'})
+        rows = table.find_all('tr')
+        time_schedules = []
+        for row in rows[1:]:
+            row_data = []
+            for cell in row.find_all('td'):
+                cell_text = cell.text.strip()
+                cell_link = cell.find('a')
+                if cell_link is not None:
+                    cell_text += ' ' + cell_link.get('href')
+                row_data.append(cell_text)
+            time_schedules.append(row_data)
+        return time_schedules
+
+    def get_last_week_schedule(self):
+        """
+        Returns the most recent weekly schedule.
+
+        Returns
+        -------
+        list
+            the most recent weekly schedule, represented as a list of strings.
+            Returns None if no schedules are found.
+        """
+        time_schedules = self.get_table_schedules()
+        if time_schedules is None:
+            return None
+
+        # Filter schedules that contain "Semaine" and extract dates
+        week_schedules = [
+            schedule for schedule in time_schedules if "Semaine" in schedule[0]]
+        date_format = "%d-%m-%Y"
+        dates_and_schedules = []
+
+        for schedule in week_schedules:
+            # Extract date from file name
+            match = re.search(r"\d{2}-\d{2}-\d{4}", schedule[0])
+            if match:
+                date_str = match.group()
+                date = datetime.strptime(date_str, date_format)
+                dates_and_schedules.append((date, schedule))
+
+        # Sort by date and return the latest schedule
+        dates_and_schedules.sort(key=lambda x: x[0])
+        return dates_and_schedules[-1][1] if dates_and_schedules else None
+
+    def download_files(self, schedule, download_path):
+        """
+        Downloads the files associated with a given schedule.
+
+        Parameters
+        ----------
+            schedule : list
+                the schedule to download files for, represented as a list of strings
+            download_path : str
+                the path where the file should be downloaded
+
+        Returns
+        -------
+        str
+            the path to the downloaded file
+        """
+        response = self.session.get(self.url)
+        soup = BeautifulSoup(response.text, 'html.parser')
+
+        # Extract __VIEWSTATE and __EVENTVALIDATION values
+        viewstate = soup.find('input', {'id': '__VIEWSTATE'})['value']
+        eventvalidation = soup.find(
+            'input', {'id': '__EVENTVALIDATION'})['value']
+
+        # Extract eventTarget from the JavaScript function call
+        event_target = schedule[1].split("'")[1]
+
+        # Send a POST request to mimic the postback
+        post_data = {
+            '__EVENTTARGET': event_target,
+            '__EVENTARGUMENT': '',
+            '__VIEWSTATE': viewstate,
+            '__EVENTVALIDATION': eventvalidation,
+        }
+        file_response = self.session.post(self.url, data=post_data)
+
+        # Save the file
+        file_path = os.path.join(download_path, schedule[0])
+        with open(file_path, 'wb') as f:
+            f.write(file_response.content)
+
+        return file_path
+
+    def get_class_week_schedule(self, file_path, class_name, result_path):
+        """
+        Extracts the weekly schedule for a specific class from a given file.
+
+        Parameters
+        ----------
+            file_path : str
+                the path to the file to extract the schedule from
+            class_name : str
+                the name of the class to extract the schedule for
+            result_path : str
+                the path where the result PDF will be saved
+
+        Returns
+        -------
+        str
+            the path to the extracted schedule, or None if the class is not found in the file
+        """
+        # Open the existing PDF
+        with open(file_path, "rb") as file:
+            reader = PdfReader(file)
+
+            # Assume class_name is found on a specific page
+            for page_number in range(len(reader.pages)):
+                page = reader.pages[page_number]
+                content = page.extract_text()
+
+                # If class_name is found in content
+                if class_name in content:
+                    writer = PdfWriter()
+                    writer.add_page(page)
+
+                    # Save the page as a new PDF
+                    new_file_path = os.path.join(
+                        result_path, f"{class_name}.pdf")
+                    with open(new_file_path, "wb") as output_pdf:
+                        writer.write(output_pdf)
+
+                    return new_file_path
+
+        return None

esprit/utils.py

@@ -0,0 +1,93 @@
+from bs4 import BeautifulSoup
+
+
+class Utils:
+    """
+    A utility class for interacting with the ESPRIT website.
+    """
+
+    def __init__(self, session):
+        # Try both URL formats (case might matter)
+        self.url = "https://esprit-tn.com/ESPOnline/Etudiants/Accueil.aspx"
+        self.url_alt = "https://esprit-tn.com/esponline/Etudiants/Accueil.aspx"
+        self.session = session
+
+    def get_student_name(self):
+        """
+        Get the name of the student from the ESPRIT website.
+
+        Returns:
+            The name of the student, or None if the name could not be found.
+        """
+        # Try primary URL first
+        response = self.session.get(self.url, allow_redirects=True)
+        
+        # Check if we were redirected to login page
+        if 'default.aspx' in response.url or 'login' in response.url.lower():
+            # Try alternative URL
+            response = self.session.get(self.url_alt, allow_redirects=True)
+            if 'default.aspx' in response.url or 'login' in response.url.lower():
+                print("Session expired or invalid - redirected to login page.")
+                return None
+        
+        if response.status_code != 200:
+            print("Failed to load student page.")
+            return None
+        
+        soup = BeautifulSoup(response.text, 'html.parser')
+
+        # Find the span with id='Label2' and class='h4 text-info'
+        span = soup.find('span', {'id': 'Label2', 'class': 'h4 text-info'})
+        if span is not None and span.text.strip():
+            return span.text.strip()
+        
+        # Try alternative: ContentPlaceHolder1_Label2
+        span = soup.find('span', {'id': 'ContentPlaceHolder1_Label2'})
+        if span is not None and span.text.strip():
+            return span.text.strip()
+        
+        # Try alternative: just find by id='Label2'
+        span = soup.find('span', {'id': 'Label2'})
+        if span is not None and span.text.strip():
+            return span.text.strip()
+        
+        print("Student name not found on page.")
+        return None
+
+    def get_student_class(self):
+        """
+        Get the class of the student from the ESPRIT website.
+
+        Returns:
+            The class of the student, or None if the class could not be found.
+        """
+        # Try primary URL first
+        response = self.session.get(self.url, allow_redirects=True)
+        
+        # Check if we were redirected to login page
+        if 'default.aspx' in response.url or 'login' in response.url.lower():
+            # Try alternative URL
+            response = self.session.get(self.url_alt, allow_redirects=True)
+            if 'default.aspx' in response.url or 'login' in response.url.lower():
+                print("Session expired or invalid - redirected to login page.")
+                return None
+        
+        if response.status_code != 200:
+            print("Failed to load student page.")
+            return None
+        
+        soup = BeautifulSoup(response.text, 'html.parser')
+
+        # Find the span with id='Label3'
+        span = soup.find('span', {'id': 'Label3'})
+        if span is not None and span.text.strip():
+            return span.text.strip()
+        
+        # Try alternative: ContentPlaceHolder1_Label3
+        span = soup.find('span', {'id': 'ContentPlaceHolder1_Label3'})
+        if span is not None and span.text.strip():
+            return span.text.strip()
+        
+        print("Student class not found on page.")
+        return None
+

esprit_py-0.5.0.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Aymen Hmani
+
+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.

esprit_py-0.5.0.dist-info/METADATA

@@ -0,0 +1,214 @@
+Metadata-Version: 2.1
+Name: esprit-py
+Version: 0.5.0
+Summary: A fast, lightweight Python library for interacting with data from esprit-tn.com
+Home-page: https://github.com/TheLime1/esprit.py
+Author: Lime1 (Aymen Hmani)
+Keywords: python,api
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: Unix
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: License :: OSI Approved :: MIT License
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests
+Requires-Dist: beautifulsoup4
+Requires-Dist: PyPDF2
+Requires-Dist: numpy
+Requires-Dist: pandas
+
+
+# <img src="https://esprit.tn/favicon.ico" width="28px" /> esprit-py
+
+
+
+[![PyPI version](https://badge.fury.io/py/esprit-py.svg)](https://pypi.org/project/esprit-py/)
+
+
+
+> [!NOTE]
+
+> Please note that this library is not an official API provided by Esprit and is intended for educational and personal use only.
+
+
+
+## Features
+
+
+
+- **Fast & Lightweight**: 5-10x faster than previous versions (no Selenium/browser required)
+
+- Get your exact timetable pdf *not 300 pages pdf*
+
+- Get your grades
+
+- Get your absences
+
+- Get your credits
+
+- Calculate your total semester average
+
+- **New**: Logout functionality for proper session management
+
+
+
+## Installation
+
+
+
+```bash
+
+pip install --upgrade esprit-py
+
+```
+
+
+
+## Examples
+
+
+
+get your total avreage:
+
+
+
+```python
+
+from esprit import Esprit
+
+
+
+# Replace with your actual ID and password
+
+id = 'ID'
+
+password = 'PASSWORD'
+
+
+
+grades = None
+
+
+
+# Keep trying to get grades until it is successful cuz esprit use garabage servers
+
+while grades is None:
+
+    try:
+
+        # Create an Esprit object
+
+        esprit = Esprit()
+
+
+
+        # Attempt to log in
+
+        esprit.login(id, password)
+
+
+
+        # Get grades
+
+        grades = esprit.get_grades()
+
+
+
+    except Exception as e:
+
+        print(f"An error occurred: {e}. Retrying...")
+
+
+
+if grades is not None:
+
+    for grade in grades:
+
+        print(grade)
+
+else:
+
+    print("Failed to get grades.")
+
+
+
+esprit.calculate_average(grades)
+
+
+
+# Logout when done
+
+esprit.logout()
+
+
+
+```
+
+
+
+get a list of all your absences;
+
+
+
+```python
+
+from esprit import Esprit
+
+
+
+# Create an Esprit object
+
+esprit = Esprit()
+
+
+
+# Replace with your actual ID and password
+
+id = 'ID'
+
+password = 'PASSWORD'
+
+
+
+# Attempt to log in
+
+if esprit.login(id, password):
+
+    print("Login successful.")
+
+else:
+
+    print("Login failed.")
+
+
+
+# Get absences
+
+absences = esprit.get_absences()
+
+if absences is not None:
+
+    for absence in absences:
+
+        print(absence)
+
+else:
+
+    print("Failed to get absences.")
+
+
+
+# Logout when done
+
+esprit.logout()
+
+
+
+```
+
+
+
+More examples can be found in the [examples folder](examples)

esprit_py-0.5.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+esprit/__init__.py,sha256=PnahGRQ5xmA26XMFaj9ImLty9OEmYwnBqLanvGXZwwU,28
+esprit/absence.py,sha256=1CE7FCnWUr9omNXkgFH4Q3Vq5FkonjAEOmAOarXoCqU,1649
+esprit/auth.py,sha256=9tLQadQYu0Y5yfQcOLvlzSOYhSURd75OLe1BpBgQ86w,20882
+esprit/credit.py,sha256=mcrBWGiTh-aYuSFti2LKZtuxj5MXOI8a0mxEvXjFXRU,3216
+esprit/esprit.py,sha256=OyHR4rTWv_wxHnvIYoCZ9yTwxZKuOsTHoxF4Km_-Ulo,2289
+esprit/grade.py,sha256=Wt5rjcqHAaG2gQ5DaqaMUMkP7ImMhZhQqoJTxTZkXhk,3504
+esprit/time_schedule.py,sha256=APash3wNe09kdwJDl3B1Du1WH71h6j3TAirVGoWndCc,6473
+esprit/utils.py,sha256=QeBB8Nkh5w_Es5NQNAY_2Zps9fCAsbs88FQmPbtlWKQ,3591
+esprit_py-0.5.0.dist-info/LICENSE,sha256=DOcn7qpE6TsUEcakIsDDKm757jx5YlQ8fXDiED21P_w,1089
+esprit_py-0.5.0.dist-info/METADATA,sha256=Yy5AYedoA_7FD1p7QGpoZ_D9KNghNH6O6gPCSERSoNc,3054
+esprit_py-0.5.0.dist-info/WHEEL,sha256=pkctZYzUS4AYVn6dJ-7367OJZivF2e8RA9b_ZBjif18,92
+esprit_py-0.5.0.dist-info/top_level.txt,sha256=aS9besFTZ4EYTsoBJVf3GaMjQtJLgLaK7WqAxSvGVdQ,7
+esprit_py-0.5.0.dist-info/RECORD,,

esprit_py-0.5.0.dist-info/WHEEL

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

esprit_py-0.5.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+esprit