schoolapp-api 2.0.0__py3-none-any.whl

schoolapp_api/__init__.py

@@ -0,0 +1,10 @@
+"""
+Professional School App API Client
+"""
+
+from .school_app_client import SchoolAppClient
+from .http_client import HTTPClient
+from .auth import AuthManager
+
+__version__ = "2.0.0"
+__all__ = ["SchoolAppClient", "HTTPClient", "AuthManager"]

schoolapp_api/auth.py

@@ -0,0 +1,81 @@
+"""
+Authentication and CSRF token management
+"""
+import re
+import logging
+from schoolapp_api.constants import LOGIN_URL
+
+logger = logging.getLogger(__name__)
+
+class AuthManager:
+    """Handles authentication and CSRF token management"""
+    
+    def __init__(self, http_client, base_url):
+        self.http_client = http_client
+        self.base_url = base_url
+        self.login_url = LOGIN_URL
+        self.csrf_token = None
+        self.logged_in = False
+    
+    @staticmethod
+    def extract_csrf_token(html_content):
+        """Extract CSRF token from HTML content"""
+        match = re.search(r'name="_csrf"\s+value="([^"]+)"', html_content)
+        return match.group(1) if match else None
+    
+    def update_csrf_token(self, html_content):
+        """Update CSRF token from HTML content"""
+        new_csrf = self.extract_csrf_token(html_content)
+        if new_csrf:
+            self.csrf_token = new_csrf
+            return True
+        return False
+    
+    def login(self, email, password):
+        """Login and maintain session"""
+        if self.logged_in:
+            logger.info("Already logged in!")
+            return True
+        
+        logger.info("Fetching login page...")
+        code, url, content = self.http_client.get(self.login_url)
+        
+        if not content or not self.update_csrf_token(content):
+            logger.error("Failed to fetch login page or retrieve CSRF token.")
+            return False
+        
+        logger.info(f"Got CSRF token, logging in...")
+        login_data = {
+            '_csrf': self.csrf_token,
+            'email': email,
+            'password': password
+        }
+        
+        code, response_url, content = self.http_client.post(
+            self.login_url, 
+            login_data, 
+            referer=self.login_url
+        )
+        
+        if response_url and ("/login" in response_url and "error" in response_url):
+            logger.error("Login failed! Invalid credentials.")
+            return False
+        
+        logger.info("Login successful!")
+        self.logged_in = True
+        return True
+    
+    def is_logged_in(self):
+        """Check if currently logged in"""
+        return self.logged_in
+    
+    def refresh_csrf_from_url(self, url):
+        """Fetch a fresh CSRF token from a specific page"""
+        try:
+            code, response_url, content = self.http_client.get(url)
+            if content and self.update_csrf_token(content):
+                return True
+            return False
+        except Exception as e:
+            logger.warning(f"CSRF refresh warning: {e}")
+            return False

schoolapp_api/constants.py

@@ -0,0 +1,38 @@
+"""
+Centralized constants for the School App API
+"""
+
+BASE_URL = "https://schoolapp.ensam-umi.ac.ma"
+
+# Endpoints
+LOGIN_URL = f"{BASE_URL}/login"
+INDEX_URL = f"{BASE_URL}/index"
+MODULES_URL = f"{BASE_URL}/plan-etudes-view/modules"
+FILIERES_URL = f"{BASE_URL}/plan-etudes-view/filieres"
+
+# Student Grade Endpoints
+CURRENT_ELEM_URL = f"{BASE_URL}/student/noteselem-encours"
+CURRENT_MOD_URL = f"{BASE_URL}/student/notesmod-encours"
+ELEM_URL = f"{BASE_URL}/student/noteselem"
+MOD_URL = f"{BASE_URL}/student/notesmod"
+ANNEES_URL = f"{BASE_URL}/student/notesannee"
+SEMESTRES_URL = f"{BASE_URL}/student/notessem"
+
+# Absence and Sanctions Endpoints
+ABSENCES_URL = f"{BASE_URL}/student/absence/bilan"
+SANCTIONS_URL = f"{BASE_URL}/student/absence/sanctions"
+
+# Stats Endpoints
+EVAL_STAT_URL = f"{BASE_URL}/notes-stat/elemevalsat"
+MOD_STAT_URL = f"{BASE_URL}/notes-stat/modsat"
+ANNEE_STAT_URL = f"{BASE_URL}/notes-stat/anneesat"
+SEM_STAT_URL = f"{BASE_URL}/notes-stat/semsat"
+
+# Default Headers
+DEFAULT_HEADERS = {
+    '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',
+    'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7',
+    'Accept-Language': 'en-US,en;q=0.9,fr;q=0.8',
+    'Connection': 'keep-alive',
+    'Upgrade-Insecure-Requests': '1'
+}

schoolapp_api/http_client.py

@@ -0,0 +1,67 @@
+"""
+HTTP Client with session and cookie management
+"""
+import urllib.request
+import urllib.parse
+import urllib.error
+import http.cookiejar
+import logging
+
+from schoolapp_api.constants import DEFAULT_HEADERS
+
+logger = logging.getLogger(__name__)
+
+class HTTPClient:
+    """Base HTTP client for making authenticated requests"""
+    
+    def __init__(self, base_url):
+        self.base_url = base_url
+        self.cookie_jar = http.cookiejar.CookieJar()
+        opener = urllib.request.build_opener(urllib.request.HTTPCookieProcessor(self.cookie_jar))
+        urllib.request.install_opener(opener)
+        self.headers = DEFAULT_HEADERS.copy()
+    
+    def get(self, url, params=None):
+        """Perform GET request"""
+        try:
+            if params:
+                query_string = urllib.parse.urlencode(params, doseq=True)
+                separator = "&" if "?" in url else "?"
+                url = f"{url}{separator}{query_string}"
+
+            req = urllib.request.Request(url, headers=self.headers, method="GET")
+
+            with urllib.request.urlopen(req) as response:
+                code = response.getcode()
+                response_url = response.geturl()
+                content = response.read().decode("utf-8")
+                return code, response_url, content
+
+        except urllib.error.HTTPError as e:
+            logger.error(f"HTTP Error {e.code}: {e.reason}")
+            return e.code, None, None
+        except Exception as e:
+            logger.error(f"GET Error: {e}")
+            return None, None, None
+    
+    def post(self, url, data, referer=None):
+        """Perform POST request"""
+        try:
+            encoded_data = urllib.parse.urlencode(data).encode('utf-8')
+            req = urllib.request.Request(url, data=encoded_data, headers=self.headers)
+            req.add_header('Content-Type', 'application/x-www-form-urlencoded')
+            req.add_header('Origin', self.base_url)
+            if referer:
+                req.add_header('Referer', referer)
+            
+            with urllib.request.urlopen(req) as response:
+                code = response.getcode()
+                response_url = response.geturl()
+                content = response.read().decode('utf-8')
+                return code, response_url, content
+        except urllib.error.HTTPError as e:
+            logger.error(f"HTTP Error {e.code}: {e.reason}")
+            return e.code, None, None
+        except Exception as e:
+            logger.error(f"POST Error: {e}")
+            return None, None, None

schoolapp_api/managers/__init__.py

@@ -0,0 +1,11 @@
+from .grades_manager import GradesManager
+from .attendance_manager import AttendanceManager
+from .profile_manager import ProfileManager
+from .course_manager import CourseManager
+
+__all__ = [
+    'GradesManager',
+    'AttendanceManager',
+    'ProfileManager',
+    'CourseManager'
+]

schoolapp_api/managers/attendance_manager.py

@@ -0,0 +1,15 @@
+"""
+Manager for attendance and sanctions
+"""
+from schoolapp_api.managers.base_manager import BaseManager
+from schoolapp_api.constants import ABSENCES_URL, SANCTIONS_URL
+from schoolapp_api import parsers
+
+class AttendanceManager(BaseManager):
+    """Handles fetching of absences and sanctions"""
+
+    def get_absences(self):
+        return self.get_json_or_parse(ABSENCES_URL, parsers.absences)
+
+    def get_sanctions(self):
+        return self.get_json_or_parse(SANCTIONS_URL, parsers.sanctions)

schoolapp_api/managers/base_manager.py

@@ -0,0 +1,36 @@
+"""
+Base client for shared manager logic
+"""
+import logging
+
+logger = logging.getLogger(__name__)
+
+class BaseManager:
+    """Base class for all managers"""
+    
+    def __init__(self, client):
+        self.client = client
+        self.http_client = client.http_client
+        self.auth = client.auth
+
+    def ensure_logged_in(self):
+        """Ensures the client is logged in before making requests"""
+        if not self.auth.is_logged_in():
+            logger.error("Not logged in! Call login() first.")
+            return False
+        return True
+
+    def get_json_or_parse(self, url, parser, params=None, refresh_csrf=True):
+        """Helper to fetch content, update CSRF, and parse"""
+        if not self.ensure_logged_in():
+            return None
+            
+        code, url, content = self.http_client.get(url, params=params)
+        
+        if not content:
+            return None
+            
+        if refresh_csrf:
+            self.auth.update_csrf_token(content)
+            
+        return parser.parse(content)

schoolapp_api/managers/course_manager.py

@@ -0,0 +1,45 @@
+"""
+Manager for courses and study plans
+"""
+import logging
+from schoolapp_api.managers.base_manager import BaseManager
+from schoolapp_api.constants import MODULES_URL
+from schoolapp_api import parsers
+
+logger = logging.getLogger(__name__)
+
+class CourseManager(BaseManager):
+    """Handles fetching of modules and study plans"""
+
+    def get_modules(self, niveau, filiere, semestre, refresh_csrf=False):
+        """Fetch modules for specific niveau/filiere/semestre"""
+        if not self.ensure_logged_in():
+            return None
+        
+        # Always GET modules page first to refresh CSRF token
+        logger.info("Opening modules page to refresh state...")
+        code, url, content = self.http_client.get(MODULES_URL)
+        
+        if not content:
+            return None
+        
+        self.auth.update_csrf_token(content)
+        
+        if refresh_csrf:
+            self.auth.refresh_csrf_from_url(MODULES_URL)
+        
+        logger.info(f"Fetching modules for {niveau} {filiere} {semestre}...")
+        modules_data = {
+            '_csrf': self.auth.csrf_token,
+            'niveau': niveau,
+            'filiere': filiere,
+            'semestre': semestre
+        }
+        
+        code, response_url, content = self.http_client.post(
+            MODULES_URL,
+            modules_data,
+            referer=MODULES_URL
+        )
+        
+        return parsers.modules.parse(content)

schoolapp_api/managers/grades_manager.py

@@ -0,0 +1,35 @@
+"""
+Manager for grades and academic results
+"""
+from schoolapp_api.managers.base_manager import BaseManager
+from schoolapp_api.constants import (
+    CURRENT_ELEM_URL, CURRENT_MOD_URL, ELEM_URL, MOD_URL, 
+    ANNEES_URL, SEMESTRES_URL
+)
+from schoolapp_api import parsers, types
+
+class GradesManager(BaseManager):
+    """Handles fetching of grades for elements, modules, years, and semesters"""
+
+    def get_element_notes(self, current=False):
+        url = CURRENT_ELEM_URL if current else ELEM_URL
+        data = self.get_json_or_parse(url, parsers.note_elem)
+        return [types.Element(self.client, item) for item in data] if data else []
+
+    def get_module_notes(self, current=False):
+        url = CURRENT_MOD_URL if current else MOD_URL
+        data = self.get_json_or_parse(url, parsers.note_mod)
+        # Note: In the original code, get_mod_note returned types.Element, 
+        # but it should probably return types.Module if it's for modules.
+        # Looking at original school_app_client.py:L272 it used types.Element.
+        # I'll stick to what was there but maybe use Module if appropriate.
+        # types/Module.py exists.
+        return [types.Module(self.client, item) for item in data] if data else []
+
+    def get_years(self):
+        data = self.get_json_or_parse(ANNEES_URL, parsers.annees)
+        return [types.Annee(self.client, item) for item in data] if data else []
+
+    def get_semesters(self):
+        data = self.get_json_or_parse(SEMESTRES_URL, parsers.semestres)
+        return [types.Semestre(self.client, item) for item in data] if data else []

schoolapp_api/managers/profile_manager.py

@@ -0,0 +1,15 @@
+"""
+Manager for student profile and programs
+"""
+from schoolapp_api.managers.base_manager import BaseManager
+from schoolapp_api.constants import INDEX_URL, FILIERES_URL
+from schoolapp_api import parsers
+
+class ProfileManager(BaseManager):
+    """Handles fetching of student profile and filieres"""
+
+    def get_profile(self):
+        return self.get_json_or_parse(INDEX_URL, parsers.profile)
+
+    def get_filieres(self):
+        return self.get_json_or_parse(FILIERES_URL, parsers.filieres)

schoolapp_api/parsers/__init__.py

@@ -0,0 +1,6 @@
+"""
+Parsers for School App API HTML content
+"""
+from . import absences, annees, filieres, modules, note_elem, note_mod, profile, sanctions, semestres, stats
+
+__all__ = ["absences", "annees", "filieres", "modules", "note_elem", "note_mod", "profile", "sanctions", "semestres", "stats"]

schoolapp_api/parsers/absences.py

@@ -0,0 +1,45 @@
+from bs4 import BeautifulSoup
+import re
+
+def parse(html_content):
+    """Parse HTML content containing absence details."""
+    soup = BeautifulSoup(html_content, 'html.parser')
+    result = {"summary": [], "details": []}
+    
+    tables = soup.find_all('table', class_='table table-striped table-sm')
+    if len(tables) < 2:
+        return result
+    
+    # Summary
+    for row in tables[0].find_all('tr')[1:]:
+        cells = row.find_all('td')
+        if len(cells) >= 4:
+            result["summary"].append({
+                "CodeElem": cells[0].get_text(strip=True),
+                "Intitule": cells[1].get_text(strip=True),
+                "Non_Justifiee": int(cells[2].get_text(strip=True) or 0),
+                "Justifiee": int(cells[3].get_text(strip=True) or 0)
+            })
+            
+    # Details
+    for row in tables[1].find_all('tr')[1:]:
+        cells = row.find_all('td')
+        if len(cells) >= 5:
+            result["details"].append({
+                "Element": cells[0].get_text(strip=True),
+                "Date": cells[1].get_text(strip=True),
+                "Seance": cells[2].get_text(strip=True),
+                "Justif": cells[3].get_text(strip=True).lower() == "true",
+                "Remarques": cells[4].get_text(strip=True)
+            })
+            
+    # Semester info
+    alerts = soup.find_all('div', class_='alert alert-info')
+    for alert in alerts:
+        text = alert.get_text()
+        if "semestre" in text.lower():
+            match = re.search(r'S\d', text)
+            if match:
+                result["semestre"] = match.group()
+    
+    return result

schoolapp_api/parsers/annees.py

@@ -0,0 +1,37 @@
+from bs4 import BeautifulSoup
+
+def parse(html_content):
+    """Parse HTML content containing annual averages."""
+    soup = BeautifulSoup(html_content, 'html.parser')
+    table = soup.find('table', class_='table table-striped table-sm') or soup.find('table')
+    
+    if not table:
+        return []
+    
+    headers = [th.get_text(strip=True) for th in table.find_all('th')]
+    if len(headers) < 9:
+        headers = ["Niveau", "Filiere", "AU", "Statut", "Moy Année", "PJ", "Decision", "Classement", "Releve de Notes"]
+    
+    data = []
+    tbody = table.find('tbody') or table
+    
+    for row in tbody.find_all('tr'):
+        cells = row.find_all('td')
+        if len(cells) >= 9:
+            row_data = {}
+            for i, cell in enumerate(cells[:9]):
+                if i == 8: # Download link
+                    link = cell.find('a')
+                    row_data[headers[i]] = link.get('href') if link else cell.get_text(strip=True)
+                else:
+                    val = cell.get_text(strip=True)
+                    if headers[i] in ["Moy Année", "PJ"]:
+                        try:
+                            row_data[headers[i]] = float(val) if val and val != "--" else None
+                        except ValueError:
+                            row_data[headers[i]] = val
+                    else:
+                        row_data[headers[i]] = val
+            data.append(row_data)
+            
+    return data

schoolapp_api/parsers/filieres.py

@@ -0,0 +1,63 @@
+from bs4 import BeautifulSoup
+
+def parse(html_content):
+    """
+    Parse HTML content containing a table of academic programs and return structured data.
+    
+    Args:
+        html_content (str): HTML content as a string
+        
+    Returns:
+        list: List of dictionaries with program information
+    """
+    soup = BeautifulSoup(html_content, 'html.parser')
+    
+    # Find the table - using multiple selectors to be safe
+    table = soup.find('table', class_='table table-striped table-sm mb-1 display')
+    
+    if not table:
+        # Try alternative selector
+        table = soup.find('table', {'class': 'table'})
+    
+    if not table:
+        return []
+    
+    # Extract table headers
+    headers = []
+    thead = table.find('thead')
+    if thead:
+        header_row = thead.find('tr')
+        if header_row:
+            for th in header_row.find_all('th'):
+                headers.append(th.get_text(strip=True))
+    
+    # If headers weren't found in thead, use hardcoded ones
+    if not headers:
+        headers = ["Code", "Intitule", "Departement", "Accreditation", "Descriptif", "Plan_Etudes"]
+    
+    # Clean up header names (replace underscores with spaces, fix capitalization)
+    cleaned_headers = []
+    for header in headers:
+        if header == "Plan_Etudes":
+            cleaned_headers.append("Plan d'Etude")
+        else:
+            cleaned_headers.append(header)
+    
+    # Extract table rows
+    data = []
+    tbody = table.find('tbody')
+    
+    if not tbody:
+        tbody = table  # If no tbody, search in table directly
+    
+    for row in tbody.find_all('tr'):
+        cells = row.find_all('td')
+        
+        if len(cells) >= len(cleaned_headers):
+            row_data = {}
+            for i, cell in enumerate(cells[:len(cleaned_headers)]):
+                cell_text = cell.get_text(strip=True)
+                row_data[cleaned_headers[i]] = cell_text
+            data.append(row_data)
+    
+    return data

schoolapp_api/parsers/modules.py

@@ -0,0 +1,55 @@
+from bs4 import BeautifulSoup
+
+def parse(html_content):
+    """Parse HTML content containing modules and their elements."""
+    soup = BeautifulSoup(html_content, "html.parser")
+    modules = {}
+
+    main_table = soup.find("table", class_="table table-striped table-sm mb-1 display")
+    if not main_table:
+        return {} # Return empty instead of raising error for robustness
+
+    tbody = main_table.find("tbody")
+    if not tbody:
+        return {}
+        
+    rows = tbody.find_all("tr", recursive=False)
+    current_mod = None
+
+    for row in rows:
+        classes = row.get("class", [])
+
+        if "clickable" in classes:
+            cols = row.find_all("td")
+            if len(cols) >= 10:
+                current_mod = cols[1].text.strip()
+                modules[current_mod] = {
+                    "intitule": cols[2].text.strip(),
+                    "niveau": cols[4].text.strip(),
+                    "semestre": cols[5].text.strip(),
+                    "vhmod": int(cols[6].text.strip() or 0),
+                    "coef": float(cols[7].text.strip() or 0),
+                    "seuil": float(cols[8].text.strip() or 0),
+                    "eliminatoire": float(cols[9].text.strip() or 0),
+                    "elements": []
+                }
+        elif "collapse" in classes and current_mod:
+            inner_table = row.find("table")
+            if inner_table and inner_table.find("tbody"):
+                for erow in inner_table.find("tbody").find_all("tr"):
+                    ecol = erow.find_all("td")
+                    if len(ecol) >= 10:
+                        modules[current_mod]["elements"].append({
+                            "code": ecol[0].text.strip(),
+                            "intitule": ecol[1].text.strip(),
+                            "vh_ctd": int(ecol[2].text.strip() or 0),
+                            "vh_tp": int(ecol[3].text.strip() or 0),
+                            "vh_eval": int(ecol[4].text.strip() or 0),
+                            "coef_cc": float(ecol[5].text.strip() or 0),
+                            "coef_ex": float(ecol[6].text.strip() or 0),
+                            "coef_ecrit": float(ecol[7].text.strip() or 0),
+                            "coef_tp": float(ecol[8].text.strip() or 0),
+                            "coef_elem": float(ecol[9].text.strip() or 0),
+                        })
+
+    return modules

schoolapp_api/parsers/note_elem.py

@@ -0,0 +1,33 @@
+from bs4 import BeautifulSoup
+
+def parse(html_content):
+    """Parse HTML content containing current element grades."""
+    soup = BeautifulSoup(html_content, 'html.parser')
+    table = soup.find('table', class_='table table-striped table-sm') or soup.find('table')
+    
+    if not table:
+        return []
+    
+    headers = [th.get_text(strip=True) for th in table.find_all('th')]
+    if len(headers) < 10:
+        headers = ["CodeElem", "AU", "CC", "EX", "TP", "MoySO", "RAT", "MoySR", "Moy", "Dec"]
+    
+    data = []
+    tbody = table.find('tbody') or table
+    
+    for row in tbody.find_all('tr'):
+        cells = row.find_all('td')
+        if len(cells) >= 10:
+            row_data = {}
+            for i, cell in enumerate(cells[:10]):
+                val = cell.get_text(strip=True)
+                if headers[i] in ["CC", "EX", "TP", "MoySO", "RAT", "MoySR", "Moy"]:
+                    try:
+                        row_data[headers[i]] = float(val) if val and val != "--" else None
+                    except ValueError:
+                        row_data[headers[i]] = val
+                else:
+                    row_data[headers[i]] = val
+            data.append(row_data)
+            
+    return data

schoolapp_api/parsers/note_mod.py

@@ -0,0 +1,33 @@
+from bs4 import BeautifulSoup
+
+def parse(html_content):
+    """Parse HTML content containing module grades."""
+    soup = BeautifulSoup(html_content, 'html.parser')
+    table = soup.find('table', class_='table table-striped table-sm') or soup.find('table')
+    
+    if not table:
+        return []
+    
+    headers = [th.get_text(strip=True) for th in table.find_all('th')]
+    if len(headers) < 4:
+        headers = ["CodeMod", "AU", "Moy", "Dec"]
+    
+    data = []
+    tbody = table.find('tbody') or table
+    
+    for row in tbody.find_all('tr'):
+        cells = row.find_all('td')
+        if len(cells) >= 4:
+            row_data = {}
+            for i, cell in enumerate(cells[:4]):
+                val = cell.get_text(strip=True)
+                if headers[i] == "Moy":
+                    try:
+                        row_data[headers[i]] = float(val) if val and val != "--" else None
+                    except ValueError:
+                        row_data[headers[i]] = val
+                else:
+                    row_data[headers[i]] = val
+            data.append(row_data)
+            
+    return data

schoolapp_api/parsers/profile.py

@@ -0,0 +1,87 @@
+from bs4 import BeautifulSoup
+import re
+
+def parse(html_content):
+    """
+    Parse HTML content containing user profile and return detailed user data.
+    """
+    soup = BeautifulSoup(html_content, 'html.parser')
+    
+    result = {
+        "basic_info": {},
+        "academic_info": {},
+        "administrative_info": {},
+        "personal_info": {},
+        "family_info": {},
+        "contact_info": {},
+        "download_links": {},
+        "sections": {}
+    }
+    
+    # Extract from sidebar
+    user_panel = soup.find('div', class_='user-panel')
+    if user_panel:
+        img = user_panel.find('img', class_='img-circle')
+        if img and img.get('src'):
+            result["basic_info"]["photo_url"] = img.get('src')
+        
+        info_div = user_panel.find('div', class_='info')
+        if info_div:
+            spans = info_div.find_all('span', class_='d-block')
+            if len(spans) >= 2:
+                result["basic_info"]["full_name"] = spans[0].get_text(strip=True)
+                result["basic_info"]["role"] = spans[1].get_text(strip=True)
+    
+    # Extract welcome message
+    alert_div = soup.find('div', class_='alert alert-info')
+    if alert_div:
+        result["basic_info"]["welcome_message"] = alert_div.get_text(strip=True)
+    
+    # Find all tables
+    tables = soup.find_all('table', class_='table table-striped table-sm')
+    
+    if len(tables) >= 2:
+        # Administrative data table
+        for row in tables[0].find_all('tr'):
+            cells = row.find_all(['th', 'td'])
+            if len(cells) >= 2:
+                key = cells[0].get_text(strip=True).rstrip(':').strip()
+                val = cells[1].get_text(strip=True)
+                result["administrative_info"][key] = val
+        
+        # Personal data table
+        for row in tables[1].find_all('tr'):
+            cells = row.find_all(['th', 'td'])
+            if len(cells) >= 2:
+                key = cells[0].get_text(strip=True).rstrip(':').strip()
+                val = cells[1].get_text(strip=True)
+                
+                if key in ["Code", "CNE/Masar", "Nom", "Prénom", "Nom Arabe", "Prénom Arabe", "CIN", "Sexe", "Date Naissance", "Nationalité", "Lieu_Naissance"]:
+                    result["personal_info"][key] = val
+                elif key in ["Email", "Téléphone", "Adr_Parents", "Ville", "Tel_Parents"]:
+                    result["contact_info"][key] = val
+                elif key in ["Série BAC", "Année BAC", "Niveau Accès", "Annee Accès", "Voie Accès", "Académie"]:
+                    result["academic_info"][key] = val
+                elif key in ["Prof_Père", "Prof_Mère"]:
+                    result["family_info"][key] = val
+                else:
+                    result["personal_info"][key] = val
+    
+    # Extract download links
+    attestation = soup.find('a', href=re.compile(r'attestation-scolarite'))
+    if attestation:
+        result["download_links"]["attestation_scolarite"] = attestation.get('href', '')
+    
+    main_img = soup.find('img', width='100')
+    if main_img and main_img.get('src'):
+        result["basic_info"]["large_photo_url"] = main_img.get('src')
+    
+    # Extract section titles
+    for h5 in soup.find_all('h5'):
+        text = h5.get_text(strip=True)
+        if "Situation Administrative" in text:
+            result["sections"]["administrative"] = text
+        elif "Données personnelles" in text:
+            result["sections"]["personal"] = text
+    
+    return result

schoolapp_api/parsers/sanctions.py

@@ -0,0 +1,42 @@
+from bs4 import BeautifulSoup
+import re
+
+def parse(html_content):
+    """Parse HTML content containing disciplinary sanctions."""
+    soup = BeautifulSoup(html_content, 'html.parser')
+    result = {
+        "Absences_non_justifiees": 0,
+        "Absences_justifiees": 0,
+        "Sanction": "",
+        "Message": "",
+        "Elements_non_autorises": []
+    }
+    
+    table = soup.find('table', class_='table table-striped table-sm') or soup.find('table')
+    if table:
+        for row in table.find_all('tr'):
+            cells = row.find_all('td')
+            if len(cells) == 2:
+                key = cells[0].get_text(strip=True)
+                val_cell = cells[1]
+                val_text = val_cell.get_text(strip=True)
+                
+                if "non justifiées" in key:
+                    result["Absences_non_justifiees"] = int(val_text or 0)
+                elif "justifiées" in key:
+                    result["Absences_justifiees"] = int(val_text or 0)
+                elif key == "Sanction":
+                    btn = val_cell.find('button')
+                    result["Sanction"] = btn.get_text(strip=True) if btn else val_text
+                elif key == "Message":
+                    result["Message"] = val_text
+                elif "pas autorisé" in key:
+                    result["Elements_non_autorises"] = [b.get_text(strip=True) for b in val_cell.find_all('button', class_='elem')]
+
+    alert = soup.find('div', class_='alert alert-info')
+    if alert:
+        match = re.search(r'S\d', alert.get_text())
+        if match:
+            result["Semestre"] = match.group()
+            
+    return result

schoolapp_api/parsers/semestres.py

@@ -0,0 +1,37 @@
+from bs4 import BeautifulSoup
+
+def parse(html_content):
+    """Parse HTML content containing semester averages."""
+    soup = BeautifulSoup(html_content, 'html.parser')
+    table = soup.find('table', class_='table table-striped table-sm') or soup.find('table')
+    
+    if not table:
+        return []
+    
+    headers = [th.get_text(strip=True) for th in table.find_all('th')]
+    if len(headers) < 10:
+        headers = ["Niveau", "Filiere", "Semestre", "AU", "Statut", "Moy SEM", "PJ", "Decision", "Classement", "Releve de Notes"]
+    
+    data = []
+    tbody = table.find('tbody') or table
+    
+    for row in tbody.find_all('tr'):
+        cells = row.find_all('td')
+        if len(cells) >= 10:
+            row_data = {}
+            for i, cell in enumerate(cells[:10]):
+                if i == 9: # Download link
+                    link = cell.find('a')
+                    row_data[headers[i]] = link.get('href') if link else cell.get_text(strip=True)
+                else:
+                    val = cell.get_text(strip=True)
+                    if headers[i] in ["Moy SEM", "PJ"]:
+                        try:
+                            row_data[headers[i]] = float(val) if val and val != "--" else None
+                        except ValueError:
+                            row_data[headers[i]] = val
+                    else:
+                        row_data[headers[i]] = val
+            data.append(row_data)
+            
+    return data

schoolapp_api/parsers/stats.py

@@ -0,0 +1,34 @@
+from bs4 import BeautifulSoup
+
+def parse(html_content):
+    """Extract statistics from modal/popup HTML content."""
+    soup = BeautifulSoup(html_content, 'html.parser')
+    stat_divs = soup.find_all('div', class_=lambda x: x and 'stat' in x.lower())
+    
+    expected_keys = ["Votre note", "Moyenne promo", "Max", "Min", "Ecart type", "Effectif", "Votre classement"]
+    
+    for div in stat_divs:
+        for table in div.find_all('table'):
+            rows = table.find_all('tr')
+            if len(rows) < 7:
+                continue
+                
+            stats = {}
+            for row in rows:
+                th, td = row.find('th'), row.find('td')
+                if th and td:
+                    key, val = th.get_text(strip=True), td.get_text(strip=True)
+                    try:
+                        if key in ["Effectif", "Votre classement"]:
+                            stats[key.replace(" ", "_")] = int(float(val))
+                        elif key in ["Votre note", "Moyenne promo", "Max", "Min", "Ecart type"]:
+                            stats[key.replace(" ", "_")] = float(val)
+                        else:
+                            stats[key.replace(" ", "_")] = val
+                    except (ValueError, TypeError):
+                        stats[key.replace(" ", "_")] = val
+            
+            if all(k in stats for k in expected_keys):
+                return stats
+                
+    return {}

schoolapp_api/school_app_client.py

@@ -0,0 +1,64 @@
+"""
+Professional client for interacting with the School App
+"""
+from schoolapp_api.http_client import HTTPClient
+from schoolapp_api.auth import AuthManager
+from schoolapp_api.constants import BASE_URL
+from schoolapp_api.managers import (
+    GradesManager, AttendanceManager, ProfileManager, CourseManager
+)
+
+class SchoolAppClient:
+    """Main client for the School App API"""
+    
+    def __init__(self, base_url=BASE_URL):
+        self.base_url = base_url
+        self.http_client = HTTPClient(self.base_url)
+        self.auth = AuthManager(self.http_client, self.base_url)
+        
+        # Initialize Managers
+        self.grades = GradesManager(self)
+        self.attendance = AttendanceManager(self)
+        self.profile = ProfileManager(self)
+        self.courses = CourseManager(self)
+        
+    def login(self, email, password):
+        """Authenticate user"""
+        return self.auth.login(email, password)
+    
+    # ---------------------------------------------------------
+    # Legacy / Convenience methods for backward compatibility
+    # ---------------------------------------------------------
+    
+    def get_profile(self):
+        return self.profile.get_profile()
+    
+    def get_filieres(self):
+        return self.profile.get_filieres()
+    
+    def get_absences(self):
+        return self.attendance.get_absences()
+    
+    def get_sanctions(self):
+        return self.attendance.get_sanctions()
+    
+    def get_elem_note(self):
+        return self.grades.get_element_notes()
+    
+    def get_current_elem_note(self):
+        return self.grades.get_element_notes(current=True)
+    
+    def get_mod_note(self):
+        return self.grades.get_module_notes()
+    
+    def get_current_mod_note(self):
+        return self.grades.get_module_notes(current=True)
+    
+    def get_annee(self):
+        return self.grades.get_years()
+    
+    def get_semestre(self):
+        return self.grades.get_semesters()
+    
+    def get_modules(self, niveau, filiere, semestre, refresh_csrf=False):
+        return self.courses.get_modules(niveau, filiere, semestre, refresh_csrf)

schoolapp_api/types/__init__.py

@@ -0,0 +1,9 @@
+"""
+Domain models for School App API
+"""
+from .annee import Annee
+from .element import Element
+from .module import Module
+from .semestre import Semestre
+
+__all__ = ["Annee", "Element", "Module", "Semestre"]

schoolapp_api/types/annee.py

@@ -0,0 +1,23 @@
+from .base import BaseType
+from ..constants import ANNEE_STAT_URL
+
+class Annee(BaseType):
+    """Represents an academic year result"""
+    
+    def fetch_stats(self):
+        params = {
+            'eval': "MoyAn",
+            'niveau': getattr(self, "Niveau", None),
+            'filiere': getattr(self, "Filiere", None),
+            'au': getattr(self, "AU", None),
+            'note': getattr(self, "Moy_Annee", None)
+        }
+        
+        stats = self._get_stats(ANNEE_STAT_URL, params)
+        if stats:
+            self._stats["MoyAn"] = stats
+        return stats
+        
+    @property
+    def stats(self):
+        return self._stats.get("MoyAn") or self.fetch_stats()

schoolapp_api/types/base.py

@@ -0,0 +1,34 @@
+"""
+Base class for domain models
+"""
+import logging
+
+logger = logging.getLogger(__name__)
+
+class BaseType:
+    """Base class for all domain models with client access"""
+    
+    def __init__(self, client, data):
+        self.client = client
+        for key, value in data.items():
+            # Clean up keys for valid python attributes
+            clean_key = key.replace(" ", "_").replace("é", 'e').replace("è", 'e')
+            setattr(self, clean_key, value)
+        self._stats = {}
+
+    def _ensure_logged_in(self):
+        if not self.client.auth.is_logged_in():
+            logger.error("Not logged in! Call login() first.")
+            return False
+        return True
+
+    def _get_stats(self, url, params):
+        if not self._ensure_logged_in():
+            return None
+        
+        # Add CSRF token to params
+        params['_csrf'] = self.client.auth.csrf_token
+        
+        code, url, content = self.client.http_client.get(url, params=params)
+        from schoolapp_api.parsers.stats import parse
+        return parse(content)

schoolapp_api/types/element.py

@@ -0,0 +1,42 @@
+from .base import BaseType
+from ..constants import EVAL_STAT_URL
+
+class Element(BaseType):
+    """Represents a module element (subject) with grades"""
+    
+    def fetch_stats(self, eval_type):
+        """Generic stat fetcher for element evaluations"""
+        note_map = {
+            "NoteCC": getattr(self, "CC", None),
+            "NoteEX": getattr(self, "EX", None),
+            "NoteTP": getattr(self, "TP", None),
+            "MoyElem": getattr(self, "Moy", None)
+        }
+        
+        params = {
+            'eval': eval_type,
+            'codeelem': self.CodeElem,
+            'note': note_map.get(eval_type),
+            'au': self.AU
+        }
+        
+        stats = self._get_stats(EVAL_STAT_URL, params)
+        if stats:
+            self._stats[eval_type] = stats
+        return stats
+
+    @property
+    def cc_stats(self):
+        return self._stats.get("NoteCC") or self.fetch_stats("NoteCC")
+    
+    @property
+    def ex_stats(self):
+        return self._stats.get("NoteEX") or self.fetch_stats("NoteEX")
+    
+    @property
+    def tp_stats(self):
+        return self._stats.get("NoteTP") or self.fetch_stats("NoteTP")
+    
+    @property
+    def moy_stats(self):
+        return self._stats.get("MoyElem") or self.fetch_stats("MoyElem")

schoolapp_api/types/module.py

@@ -0,0 +1,22 @@
+from .base import BaseType
+from ..constants import MOD_STAT_URL
+
+class Module(BaseType):
+    """Represents a module (collection of elements) with grades"""
+    
+    def fetch_stats(self):
+        params = {
+            'eval': "MOYMOD",
+            'codemod': getattr(self, "CodeMod", None),
+            'note': getattr(self, "Moy", None),
+            'au': getattr(self, "AU", None)
+        }
+        
+        stats = self._get_stats(MOD_STAT_URL, params)
+        if stats:
+            self._stats["MOYMOD"] = stats
+        return stats
+
+    @property
+    def stats(self):
+        return self._stats.get("MOYMOD") or self.fetch_stats()

schoolapp_api/types/semestre.py

@@ -0,0 +1,24 @@
+from .base import BaseType
+from ..constants import SEM_STAT_URL
+
+class Semestre(BaseType):
+    """Represents a semester result"""
+    
+    def fetch_stats(self):
+        params = {
+            'eval': "MoySem",
+            'niveau': getattr(self, "Niveau", None),
+            'filiere': getattr(self, "Filiere", None),
+            'semestre': getattr(self, "Semestre", None),
+            'au': getattr(self, "AU", None),
+            'note': getattr(self, "Moy_SEM", None)
+        }
+        
+        stats = self._get_stats(SEM_STAT_URL, params)
+        if stats:
+            self._stats["MoySem"] = stats
+        return stats
+        
+    @property
+    def stats(self):
+        return self._stats.get("MoySem") or self.fetch_stats()

schoolapp_api-2.0.0.dist-info/METADATA

@@ -0,0 +1,91 @@
+Metadata-Version: 2.4
+Name: schoolapp-api
+Version: 2.0.0
+Summary: Professional client for interacting with the School App API
+Author: Aferiad Kamal
+License: MIT
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: beautifulsoup4>=4.9.0
+Dynamic: license-file
+
+# School App Client - Refactored
+
+Clean, organized structure for the School App client with proper separation of concerns.
+
+## 📁 Project Structure
+
+```
+├── http_client.py         # Base HTTP client (GET/POST requests, cookie management)
+├── auth.py                # Authentication & CSRF token handling
+├── school_app_client.py   # Main API client (combines everything)
+└── example_usage.py       # Usage example
+```
+
+## 🎯 Architecture
+
+### 1. **http_client.py** - HTTP Layer
+- Handles raw HTTP operations (GET/POST)
+- Cookie jar and session management
+- Common headers configuration
+- Error handling for network requests
+
+### 2. **auth.py** - Authentication Layer
+- Login flow management
+- CSRF token extraction and updates
+- Session state tracking
+- Decoupled from HTTP implementation
+
+### 3. **school_app_client.py** - API Layer
+- High-level API methods (`get_filieres()`, `get_modules()`)
+- Orchestrates HTTP client and auth manager
+- Business logic for School App endpoints
+
+## 🚀 Usage
+
+```python
+from school_app_client import SchoolAppClient
+
+# Initialize
+client = SchoolAppClient()
+
+# Login
+client.login("your.email@example.com", "password")
+
+# Fetch data
+filieres = client.get_filieres()
+modules = client.get_modules(niveau="1A", filiere="API-MPT", semestre="S1")
+
+# If you encounter 403 errors, force CSRF refresh
+modules = client.get_modules(
+    niveau="1A", 
+    filiere="API-MPT", 
+    semestre="S1",
+    refresh_csrf=True
+)
+```
+
+## ✨ Benefits of This Structure
+
+- **Separation of Concerns**: Each module has a single responsibility
+- **Testability**: Easy to mock and unit test each layer
+- **Maintainability**: Changes in one layer don't affect others
+- **Extensibility**: Easy to add new endpoints or authentication methods
+- **Reusability**: HTTP client can be used for other projects
+
+## 🎯 Key Features
+
+- **Automatic CSRF Management**: CSRF tokens are automatically refreshed from page content
+- **Session Persistence**: Cookie-based session management keeps you logged in
+- **Smart Error Handling**: Detects 403 errors and suggests CSRF refresh
+- **Optional CSRF Force Refresh**: Use `refresh_csrf=True` to force token refresh before requests
+- **Clean Separation**: HTTP, Auth, and API layers are completely decoupled
+
+## 🔧 Potential Extensions
+
+- Add logging module
+- Implement response parsers (HTML → structured data)
+- Add caching layer
+- Create async version using `aiohttp`
+- Add retry logic with exponential backoff

schoolapp_api-2.0.0.dist-info/RECORD

@@ -0,0 +1,33 @@
+schoolapp_api/__init__.py,sha256=V-fCvFtmzWjTsi_skYgpiNBIgpGezCZ1B9j-8kUkF18,239
+schoolapp_api/auth.py,sha256=UrYiaH0pWbXYmdtGhApI7DTlbG2V7qDIIwWzGawpCY4,2605
+schoolapp_api/constants.py,sha256=dywePcMH-4OwlcUQjed0yWCzSUm-5alj3VbbpJoMaE0,1449
+schoolapp_api/http_client.py,sha256=yrP7x2DTr0MAp9_0IlIuw7SZxUq4ZAcmMBcpYVi-4vk,2524
+schoolapp_api/school_app_client.py,sha256=RKrD-rKgQEr5wwqGz_tsmeBwYNmkkJTRxuPFMU3CFXs,2090
+schoolapp_api/managers/__init__.py,sha256=WJPekNC25Q-KiMgfb9jsy4hJlkUu7EEcApDameOlARM,292
+schoolapp_api/managers/attendance_manager.py,sha256=sFaCORN_-zMtGUxr-NGoyV7FpFsxZ9LKXELB_PHcbSg,511
+schoolapp_api/managers/base_manager.py,sha256=VgpzQWZta0SRAE8qjTAZvoEsN6fvteZVhMu_yJNeR9g,1069
+schoolapp_api/managers/course_manager.py,sha256=sUfC0MxhJ6K-zCLsyHd_RIoY-ixa5WTUiqTm7WfgYh0,1455
+schoolapp_api/managers/grades_manager.py,sha256=tSZpH8CIjKYgqbPUz9cc8FGsEPXKTQUbZMlFlUjcqgE,1622
+schoolapp_api/managers/profile_manager.py,sha256=qcfeqj214thzGT6dLGj9254oIn1X76qejjZ3ztmd2Jg,506
+schoolapp_api/parsers/__init__.py,sha256=7ISBuK6HAJVqBMIK-tmkg3DZm4Dt2jS-tHAfVxRQHuE,291
+schoolapp_api/parsers/absences.py,sha256=13FtJwSk0r96PnROj-l_U6dGPi2aPrfmHOu2VOP073o,1655
+schoolapp_api/parsers/annees.py,sha256=UPV_ZEqNUiGFCZNgkPea-KAazqVYumvXpbhvNTnWFvo,1476
+schoolapp_api/parsers/filieres.py,sha256=EzFB-k3_Hbs0BbLVaisA3DZPSt6jGMDBoQcAkksxwwE,2014
+schoolapp_api/parsers/modules.py,sha256=BVGLwYM3Y2qp1jjeUCo_XEbAqy-vtA_JtSUA7F5ylsE,2442
+schoolapp_api/parsers/note_elem.py,sha256=uRSHnUfqLlrG3NbEEyFFfe15LqmIgiwVG_kNlHGdMI4,1247
+schoolapp_api/parsers/note_mod.py,sha256=daKEdxpVgdn0pcjhb5pk_OiIkdw0kupvzVCLcZrS9yg,1146
+schoolapp_api/parsers/profile.py,sha256=RObf52YjSuYjvQPKaWgtCeTkPiLZww9FSI-tDKc9TaU,3564
+schoolapp_api/parsers/sanctions.py,sha256=BvmcQ3QtX7l6XAsrUKEyKQ0UCJjeMPSJ7QA824IZY2Y,1681
+schoolapp_api/parsers/semestres.py,sha256=h7rWfpYT12ngBU__Mj9NBxt1h9IvygL-TvNEAiQh2pA,1487
+schoolapp_api/parsers/stats.py,sha256=XWAa16GcaSwDzPCVjp12z_iPfHKYycqAlK8Id35rTQI,1472
+schoolapp_api/types/__init__.py,sha256=K6jiJoAJqKB_Om5t6h3A-u_-IWDz8EoCI5dtqeL1a_8,216
+schoolapp_api/types/annee.py,sha256=ujiRymGg6_CRv7md_gVz2WvWgQVer_bnEQ_0T-sWrSc,703
+schoolapp_api/types/base.py,sha256=dcL2MIeKKdWi89Z5YvQRrL5uDWa4AIXOPdY_zVgNpVk,1087
+schoolapp_api/types/element.py,sha256=mLMY40l9M3D9uetC_XZMrfQ2owp1e7pHHT77GUPyrW8,1303
+schoolapp_api/types/module.py,sha256=xQw8DuOgAjxsOekH4Uml5BelV_g4CD7kkOY22eoflEA,657
+schoolapp_api/types/semestre.py,sha256=5ecxLWSO4keDVVz8qK6rmNVg2m268yeGSLhWStXDLsc,755
+schoolapp_api-2.0.0.dist-info/licenses/LICENSE,sha256=3UxAU5kFcqKpWRRnrXsCqiggKMDeADpqlq341CITRp0,1095
+schoolapp_api-2.0.0.dist-info/METADATA,sha256=qyAH4n8vVZATg5ywky5k62ukjigdK2eNO0culf-HNqA,2884
+schoolapp_api-2.0.0.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
+schoolapp_api-2.0.0.dist-info/top_level.txt,sha256=bz-Z6plU3kx5xtaxm1nnpwKvrs3hQWUai0aKGbV0UH4,14
+schoolapp_api-2.0.0.dist-info/RECORD,,

schoolapp_api-2.0.0.dist-info/WHEEL

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

schoolapp_api-2.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) [2026] [Aferiad Kamal]
+
+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.

schoolapp_api-2.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+schoolapp_api