Upload 31 files

.gitignore

@@ -0,0 +1,6 @@
+tests/
+constants/priv_constants.py
+__pycache__/
+venv/
+test.py
+.vscode

Dockerfile

@@ -0,0 +1,13 @@
+FROM python:3.9
+
+RUN useradd -m -u 1000 user
+USER user
+ENV PATH="/home/user/.local/bin:$PATH"
+
+WORKDIR /app
+
+COPY --chown=user ./requirements.txt requirements.txt
+RUN pip install --no-cache-dir --upgrade -r requirements.txt
+
+COPY --chown=user . /app
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

app.py

@@ -0,0 +1,128 @@
+import uvicorn
+from aiohttp import ClientSession
+from gen_session import gen_session
+from get_marks import get_marks_data
+from get_grades import get_grades_data
+from get_profile import get_profile_data
+from fastapi.responses import JSONResponse
+from get_timetable import get_timetable_data
+from get_attendance import get_attendance_data
+from get_exam_schedule import get_examSchedule_data
+from get_sem_id import _get_all_sem_ids, _get_sem_id
+from fastapi import FastAPI, Request, HTTPException, status, Form
+
+app = FastAPI()
+
+
+def basic_creds_check(username: str | None, password: str | None):
+    if not username or not password:
+        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED)
+
+
+@app.get("/")
+async def root():
+    return {"message": "VTOP-AP API"}
+
+
+async def handle_request(data_func, num_parameters, username, password):
+    basic_creds_check(username, password)
+    async with ClientSession() as sess:
+        session_result = await gen_session(sess, username, password)
+        if session_result == 0:
+            raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED)
+        if num_parameters == 3:
+            return await data_func(sess, username, session_result)
+        else:
+            return await data_func(
+                sess,
+                username,
+                await _get_sem_id(sess, username, session_result),
+                session_result,
+            )
+
+
+@app.post("/api/attendance")
+@app.post("/api/timetable")
+@app.post("/api/examSchedule")
+async def handle_4param_data_functions(
+    request: Request, username: str = Form(...), password: str = Form(...)
+):
+    data_func = {
+        "/api/attendance": get_attendance_data,
+        "/api/timetable": get_timetable_data,
+        "/api/examSchedule": get_examSchedule_data,
+    }
+    return await handle_request(data_func[request.url.path], 4, username, password)
+
+
+@app.post("/api/grades")
+@app.post("/api/profile")
+@app.post("/api/semIDs")
+async def handle_3param_data_functions(
+    request: Request, username: str = Form(...), password: str = Form(...)
+):
+    data_func = {
+        "/api/grades": get_grades_data,
+        "/api/profile": get_profile_data,
+        "/api/semIDs": _get_all_sem_ids,
+    }
+    return await handle_request(data_func[request.url.path], 3, username, password)
+
+
+@app.post("/api/verify")
+async def verify_creds(username: str = Form(...), password: str = Form(...)):
+    basic_creds_check(username, password)
+
+    async with ClientSession() as sess:
+        session_result = await gen_session(sess, username, password)
+        if session_result == 0:
+            raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED)
+        else:
+            return JSONResponse(
+                content={"csrf_token": session_result}, status_code=status.HTTP_200_OK
+            )
+
+
+@app.post("/api/all")
+async def all_data(username: str = Form(...), password: str = Form(...)):
+    basic_creds_check(username, password)
+
+    async with ClientSession() as sess:
+        session_result = await gen_session(sess, username, password)
+        if session_result == 0:
+            raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED)
+        semID = await _get_sem_id(sess, username, session_result)
+        data = {
+            "profile": await get_profile_data(sess, username, session_result),
+            "attendance": await get_attendance_data(
+                sess, username, semID, session_result
+            ),
+            "semIDs": await _get_all_sem_ids(sess, username, session_result),
+            "grades": await get_grades_data(sess, username, session_result),
+            "examSchedule": await get_examSchedule_data(
+                sess, username, semID, session_result
+            ),
+            "timetable": await get_timetable_data(
+                sess, username, semID, session_result
+            ),
+        }
+
+        return data
+
+
+@app.post("/api/marks")
+async def marks(
+    username: str = Form(...), password: str = Form(...), semID: str = Form(...)
+):
+    basic_creds_check(username, password)
+
+    async with ClientSession() as sess:
+        session_result = await gen_session(sess, username, password)
+        if session_result == 0:
+            raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED)
+
+        return await get_marks_data(sess, username, semID, session_result)
+
+
+if __name__ == "__main__":
+    uvicorn.run(app, host="localhost", port=7860)

constants/constants.py

@@ -0,0 +1,14 @@
+user_agent_header = {
+    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 Safari/537.36 Edg/114.0.1823.67"
+}
+
+vtop_base_url = "https://vtop.vitap.ac.in/vtop/"
+
+vtop_profile_url = f"{vtop_base_url}studentsRecord/StudentProfileAllView"
+vtop_process_timetable_url = f"{vtop_base_url}processViewTimeTable"
+vtop_semID_list_url = f"{vtop_base_url}academics/common/StudentAttendance"
+vtop_process_attendance_url = f"{vtop_base_url}processViewStudentAttendance"
+vtop_process_attendance_detail_url = f"{vtop_base_url}processViewAttendanceDetail"
+vtop_doMarks_view_url = f"{vtop_base_url}examinations/doStudentMarkView"
+vtop_gradeHistory_url = f"{vtop_base_url}examinations/examGradeView/StudentGradeHistory"
+vtop_doExamSchedule_url = f"{vtop_base_url}examinations/doSearchExamScheduleForStudent"

gen_session.py

@@ -0,0 +1,46 @@
+import aiohttp
+from constants.constants import user_agent_header
+from utils.captcha_solver import solve_base64
+from utils.payloads import get_login_payload
+import re
+
+
+async def gen_session(sess: aiohttp.ClientSession, username: str, password: str):
+    try:
+        async with sess.get(
+            "https://vtop.vitap.ac.in/vtop/", headers=user_agent_header
+        ):
+            async with sess.get("https://vtop.vitap.ac.in/vtop/open/page") as csrf:
+                csrf_token = re.search(
+                    r'name="_csrf" value="(.*)"', await csrf.text()
+                ).group(1)
+                await sess.post(
+                    "https://vtop.vitap.ac.in/vtop/prelogin/setup",
+                    data={"_csrf": csrf_token, "flag": "VTOP"},
+                )
+                await sess.get("https://vtop.vitap.ac.in/vtop/init/page")
+                async with sess.get("https://vtop.vitap.ac.in/vtop/login") as req:
+                    captcha = solve_base64(
+                        re.search(r';base64,(.+)"', await req.text()).group(1)
+                    )
+                    async with sess.post(
+                        "https://vtop.vitap.ac.in/vtop/login",
+                        data=get_login_payload(
+                            csrf_token,
+                            username,
+                            password,
+                            captcha,
+                        ),
+                    ) as final:
+                        csrf = re.search(
+                            r'var csrfValue = "(.*)";', await final.text()
+                        ).group(1)
+                        if "Invalid" in await final.text():
+                            return 0
+                        elif len(csrf) == 36:
+                            return csrf
+                        else:
+                            return await gen_session(sess, username, password)
+
+    except Exception:
+        return await gen_session(sess, username, password)

get_attendance.py

@@ -0,0 +1,116 @@
+import re
+import aiohttp
+import pandas as pd
+from io import StringIO
+
+from constants.constants import (
+    vtop_process_attendance_url,
+    vtop_process_attendance_detail_url,
+)
+from utils.payloads import (
+    get_attendance_payload,
+    get_attendance_detail_payload,
+)
+
+
+async def _get_attendance_page(
+    sess: aiohttp.ClientSession, username: str, semID: str, csrf: str
+):
+    async with sess.post(
+        vtop_process_attendance_url, data=get_attendance_payload(username, semID, csrf)
+    ) as req:
+        return await req.text()
+
+
+async def _get_attendance_detail_page(
+    sess: aiohttp.ClientSession, csrf, semID, username, courseID, courseType
+):
+    async with sess.post(
+        vtop_process_attendance_detail_url,
+        data=get_attendance_detail_payload(csrf, semID, username, courseID, courseType),
+    ) as req:
+        return await req.text()
+
+
+def _get_class_type(classType: str):
+    if classType == "Embedded Theory":
+        return "ETH"
+    elif classType == "Embedded Lab":
+        return "ELA"
+    elif classType == "Theory Only":
+        return "TH"
+    elif classType == "Lab Only":
+        return "LO"
+
+
+def _parse_attendance_detail(attendance_detail_page: str):
+    attendance_detail_table = pd.read_html(StringIO(attendance_detail_page))
+    if len(attendance_detail_table) < 2:
+        return {}
+    attendance_detail_table = attendance_detail_table[1]
+    attendance_detail = {}
+
+    for index, row in attendance_detail_table.iterrows():
+        attendance_detail[str(row["Sl.No."])] = {
+            "status": row["Status"],
+            "date": row["Date"],
+            "time": row["Day / Time"],
+        }
+
+    return attendance_detail
+
+
+async def _parse_attendance(
+    attendance_page: str,
+    sess: aiohttp.ClientSession,
+    username: str,
+    csrf: str,
+    semID: str,
+):
+    table_df = pd.read_html(StringIO(attendance_page))[0]
+
+    attendance = []
+
+    for index, row in table_df.iterrows():
+        code = row["Course Detail"].split("-")[0].strip()
+        slot = row["Class Detail"].split("-")[1].strip()
+        if "Total Number Of Credits" in code:
+            if "0" in code:
+                raise Exception
+            continue
+
+        attendance.append(
+            {
+                "classID": row["Class Detail"].split("-")[0].strip(),
+                "name": row["Course Detail"].split("-")[1].strip(),
+                "courseType": row["Course Detail"].split("-")[2].strip(),
+                "slot": slot,
+                "totalClasses": str(row["Total Classes"]),
+                "attendedClasses": str(row["Attended Classes"]),
+                "attendancePercentage": row["Attendance Percentage"][:-1],
+                "attendanceDetail": _parse_attendance_detail(
+                    await _get_attendance_detail_page(
+                        sess,
+                        csrf,
+                        semID,
+                        username,
+                        re.search(f";(\w*_{code}_\d*)&", attendance_page).group(1),
+                        _get_class_type(row["Course Detail"].split("-")[2].strip()),
+                    )
+                ),
+            }
+        )
+
+    return attendance
+
+
+async def get_attendance_data(
+    sess: aiohttp.ClientSession, username: str, semID: str, csrf: str
+):
+    return await _parse_attendance(
+        await _get_attendance_page(sess, username, semID, csrf),
+        sess,
+        username,
+        csrf,
+        semID,
+    )

get_exam_schedule.py

@@ -0,0 +1,65 @@
+import re
+import aiohttp
+import pandas as pd
+from io import StringIO
+
+from utils.payloads import get_examSchedule_payload
+from constants.constants import vtop_doExamSchedule_url
+
+
+async def _get_examSchedule_page(
+    sess: aiohttp.ClientSession, username: str, semID: str, csrf: str
+) -> str:
+    async with sess.post(
+        vtop_doExamSchedule_url, data=get_examSchedule_payload(username, semID, csrf)
+    ) as req:
+        return await req.text()
+
+
+def _return_dash_if_not_str(value):
+    if isinstance(value, str):
+        return value
+    else:
+        return "-"
+
+
+async def _parse_examSchedule(examSchedule_page: str):
+    try:
+        examSchedule_table = pd.read_html(StringIO(examSchedule_page))[0]
+    except ValueError:
+        return {}
+    examSchedule_data = {}
+
+    current_exam = ""
+    for index, row in examSchedule_table.iterrows():
+        if index == 0:
+            continue
+        if re.search("\D", row[0]):
+            current_exam = row[0]
+            examSchedule_data[current_exam] = {}
+        else:
+            examSchedule_data[current_exam][row[1]] = {
+                "name": row[2],
+                "type": row[3],
+                "classID": row[4],
+                "slot": row[5],
+                "date": _return_dash_if_not_str(row[6]),
+                "session": _return_dash_if_not_str(row[7]),
+                "reportingTime": _return_dash_if_not_str(row[8]),
+                "duration": _return_dash_if_not_str(row[9]),
+                "venue": row[10].split("-")[0],
+                "roomNo": row[10].split("-")[1],
+                "seatLocation": row[11],
+                "seatNo": row[12],
+            }
+
+    examSchedule_data.pop("S.No.")
+    return examSchedule_data
+
+
+async def get_examSchedule_data(
+    sess: aiohttp.ClientSession, username: str, semID: str, csrf: str
+) -> dict:
+    examSchedule_page = await _get_examSchedule_page(sess, username, semID, csrf)
+    examSchedule_data = await _parse_examSchedule(examSchedule_page)
+    return examSchedule_data

get_grades.py

@@ -0,0 +1,48 @@
+import aiohttp
+import pandas as pd
+from io import StringIO
+from constants.constants import vtop_gradeHistory_url
+from utils.payloads import get_gradeHistory_payload
+
+
+async def _get_grades_page(
+    sess: aiohttp.ClientSession, username: str, csrf: str
+) -> str:
+    async with sess.post(
+        vtop_gradeHistory_url, data=get_gradeHistory_payload(username, csrf)
+    ) as req:
+        return await req.text()
+
+
+async def get_grades_data(sess: aiohttp.ClientSession, username: str, csrf: str):
+    grades_page = await _get_grades_page(sess, username, csrf)
+
+    try:
+        tables = pd.read_html(StringIO(grades_page))
+        data_table = tables[1]
+        data_summary_table = tables[-1]
+    except Exception:
+        return {}
+
+    grade_data = {}
+
+    grade_data["creditsEarned"] = str(data_summary_table.iloc[0, 1])
+    grade_data["cgpa"] = str(data_summary_table.iloc[0, 2])
+
+    grade_data["numOfEachGrade"] = {}
+    grade_data["subjects"] = {}
+    grade_data["numOfEachGrade"]["S"] = str(data_summary_table.iloc[0, 3])
+    for i in range(0, 6):
+        grade_data["numOfEachGrade"][chr(65 + i)] = str(
+            data_summary_table.iloc[0, 4 + i]
+        )
+
+    for i in range(2, len(data_table)):
+        grade_data["subjects"][data_table.iloc[i, 1]] = {
+            "name": data_table.iloc[i, 2],
+            "type": data_table.iloc[i, 3],
+            "credits": data_table.iloc[i, 4],
+            "grade": data_table.iloc[i, 5],
+        }
+
+    return grade_data

get_marks.py

@@ -0,0 +1,53 @@
+import aiohttp
+import pandas as pd
+from io import StringIO
+
+from constants.constants import vtop_doMarks_view_url
+from utils.payloads import get_doMarks_view_payload
+
+
+async def _get_doMarks_view_page(
+    sess: aiohttp.ClientSession, username: str, semID: str, csrf: str
+) -> str:
+    async with sess.post(
+        vtop_doMarks_view_url, data=get_doMarks_view_payload(username, semID, csrf)
+    ) as req:
+        return await req.text()
+
+
+def _parse_marks(marks_page):
+    try:
+        tables = pd.read_html(StringIO(marks_page))
+    except ValueError:
+        return {}
+
+    course_details = tables[0].iloc[1::2, :]
+    marks_data = {}
+
+    for i in range(course_details.shape[0]):
+        course = course_details.iloc[i]
+        marks_data[course[1]] = {
+            "courseName": course[3],
+            "courseType": course[4],
+            "professor": course[6],
+            "courseSlot": course[7],
+            "marks": {},
+        }
+
+        current_course_table = tables[i + 1]
+        for j in range(1, current_course_table.shape[0]):
+            entry = current_course_table.iloc[j]
+            marks_data[course[1]]["marks"][entry[1]] = {
+                "maxMarks": entry[2],
+                "maxWeightageMarks": entry[3],
+                "scoredMarks": entry[5],
+                "scoredWeightageMarks": entry[6],
+            }
+
+    return marks_data
+
+
+async def get_marks_data(
+    sess: aiohttp.ClientSession, username: str, semID: str, csrf: str
+):
+    return _parse_marks(await _get_doMarks_view_page(sess, username, semID, csrf))

get_profile.py

@@ -0,0 +1,55 @@
+import re
+import string
+import aiohttp
+import pandas as pd
+from io import StringIO
+
+from constants.constants import vtop_profile_url
+from utils.payloads import get_profile_payload
+
+
+def _get_value_from_column1(text: str, df: pd.DataFrame):
+    row = df[df[0] == text]
+    if not row.empty:
+        return str(row.iloc[0, 1])
+    else:
+        return str(None)
+
+
+async def _get_profile_page(
+    sess: aiohttp.ClientSession, username: str, csrf: str
+) -> str:
+    async with sess.post(
+        vtop_profile_url, data=get_profile_payload(username, csrf)
+    ) as req:
+        return await req.text()
+
+
+async def get_profile_data(
+    sess: aiohttp.ClientSession, username: str, csrf: str
+) -> dict:
+    profile_page = await _get_profile_page(sess, username, csrf)
+    data = {}
+    tables = pd.read_html(StringIO(profile_page))
+
+    desired_fields_table_0 = {
+        "Student Name": "STUDENT NAME",
+        "Application Number": "APPLICATION NUMBER",
+    }
+
+    desired_fields_table_3 = {
+        "Mentor Name": "FACULTY NAME",
+        "Mentor Cabin": "CABIN",
+        "Mentor Email": "FACULTY EMAIL",
+        "Mentor intercom": "FACULTY INTERCOM",
+        "Mentor Mobile Number": "FACULTY MOBILE NUMBER",
+    }
+
+    data["image"] = re.findall(r'src="data:null;base64,(.*)"', profile_page)[0]
+    data["VIT Registration Number"] = username
+    for key, field in desired_fields_table_0.items():
+        data[key] = string.capwords(_get_value_from_column1(field, tables[0]))
+    for key, field in desired_fields_table_3.items():
+        data[key] = _get_value_from_column1(field, tables[3])
+
+    return data

get_sem_id.py

@@ -0,0 +1,32 @@
+import re
+import aiohttp
+from bs4 import BeautifulSoup
+from constants.constants import vtop_semID_list_url
+from utils.payloads import get_attendance_semID_list_payload
+
+
+async def _get_sem_id(sess: aiohttp.ClientSession, username: str, csrf: str):
+    async with sess.post(
+        vtop_semID_list_url,
+        data=get_attendance_semID_list_payload(username, csrf),
+    ) as req:
+        return re.search('<option value="(A.*)"', await req.text()).group(1)
+
+
+async def _get_all_sem_ids(sess: aiohttp.ClientSession, username: str, csrf: str):
+    async with sess.post(
+        vtop_semID_list_url,
+        data=get_attendance_semID_list_payload(username, csrf),
+    ) as req:
+        # sem as list
+        # return re.findall('<option value="(A.*)"', await req.text())
+
+        soup = BeautifulSoup(await req.text(), "lxml")
+
+        sem_ids = {}
+        sem_ids_soup = soup.findAll("option")
+        for elem in sem_ids_soup:
+            id = elem["value"]
+            if id != "":
+                sem_ids[id] = elem.text.strip()
+        return sem_ids

get_timetable.py

@@ -0,0 +1,113 @@
+import aiohttp
+import pandas as pd
+from io import StringIO
+from bs4 import BeautifulSoup
+
+from constants.constants import vtop_process_timetable_url
+from models.period import Period
+from utils.payloads import get_timetable_payload
+
+
+DAYS_MAP = {
+    "MON": "Monday",
+    "TUE": "Tuesday",
+    "WED": "Wednesday",
+    "THU": "Thursday",
+    "FRI": "Friday",
+    "SAT": "Saturday",
+    "SUN": "Sunday",
+}
+
+VALID_DAYS = {"Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"}
+
+
+async def _get_timetable_page(
+    sess: aiohttp.ClientSession, username: str, semID: str, csrf: str
+) -> str:
+    async with sess.post(
+        vtop_process_timetable_url, data=get_timetable_payload(username, semID, csrf)
+    ) as req:
+        return await req.text()
+
+
+def _get_course_code_name_dict(soup: BeautifulSoup) -> dict:
+    course_data = soup.find("div", attrs={"id": "studentDetailsList"}).find_all(
+        "td",
+        attrs={
+            "style": "padding: 3px; font-size: 12px; border-color: #b2b2b2;vertical-align: middle;"
+        },
+    )
+    return {
+        data.text.split("-")[0].strip(): data.text.split("-")[1].split("\n")[0].strip()
+        for data in course_data
+    }
+
+
+def _parse_course_vals(cell_str: str):
+    temp_arr = str(cell_str).strip().split("-")
+    course_code = temp_arr[1]
+    cls = "-".join(temp_arr[3 : len(temp_arr) - 1])
+
+    return course_code, cls
+
+
+def _get_end_time(start_time: str, is_theory: bool = True):
+    if is_theory:
+        return f'{start_time.split(":")[0]}:50'
+    else:
+        return f'{int(start_time.split(":")[0]) + 1}:40'
+
+
+def _parse_timetable(timetable_page: str):
+    timetable = {day: [] for day in VALID_DAYS}
+    soup = BeautifulSoup(timetable_page, "lxml")
+    course_code_dict = _get_course_code_name_dict(soup)
+    dataframes = pd.read_html(StringIO(timetable_page))
+    course_details, timetable_df = dataframes[0], dataframes[1]
+
+    for row in timetable_df.itertuples(index=False):
+        if len(row) < 2 or row[1].lower() not in {"theory", "lab"}:
+            continue
+        day = DAYS_MAP.get(row[0], "Sunday")
+        is_theory = row[1].lower() == "theory"
+        if day not in timetable:
+            continue
+        for col_idx, cell in enumerate(row[2:], start=2):
+            cell_str = str(cell).strip()
+            if len(cell_str) > 3 and cell_str.count("-") >= 3:
+                code, location = _parse_course_vals(cell_str)
+                class_id = course_details.loc[
+                    course_details["Slot - Venue"].str.contains(
+                        cell_str.split("-")[0], na=False
+                    ),
+                    "Class Nbr",
+                ].iloc[0]
+                start_time = timetable_df.iloc[0, col_idx]
+                period = Period(
+                    class_id=class_id,
+                    slot=course_details.loc[
+                        course_details["Class Nbr"] == class_id, "Slot - Venue"
+                    ]
+                    .iloc[0]
+                    .split(" - ")[0],
+                    courseName=course_code_dict[code],
+                    code=code,
+                    location=location,
+                    startTime=start_time,
+                    endTime=_get_end_time(start_time, is_theory),
+                )
+                if period not in timetable[day]:
+                    timetable[day].append(period)
+    return timetable
+
+
+async def get_timetable_data(
+    sess: aiohttp.ClientSession, username: str, semID: str, csrf: str
+):
+    timetable = _parse_timetable(await _get_timetable_page(sess, username, semID, csrf))
+    for key in timetable:
+        timetable[key].sort()
+    return {
+        key: [period.to_dict() for period in period_list]
+        for key, period_list in timetable.items()
+    }

models/period.py

@@ -0,0 +1,31 @@
+class Period:
+    def __init__(self, class_id, slot, courseName, code, location, startTime, endTime):
+        self.class_id = class_id
+        self.slot = slot
+        self.courseName = courseName
+        self.code = code
+        self.location = location
+        self.startTime = startTime
+        self.endTime = endTime
+
+    def __eq__(self, other):
+        return (
+            self.slot == other.slot or self.slot[0] == other.slot[0] == "L"
+        ) and self.code == other.code
+
+    def __lt__(self, other):
+        return self.startTime < other.startTime
+
+    def to_dict(self):
+        return {
+            "classId": self.class_id,
+            "slot": self.slot,
+            "courseName": self.courseName,
+            "code": self.code,
+            "location": self.location,
+            "startTime": self.startTime,
+            "endTime": self.endTime,
+        }
+
+    def __repr__(self) -> str:
+        return str(self.to_dict())

requirements.txt

@@ -0,0 +1,8 @@
+aiohttp==3.10.5
+beautifulsoup4==4.12.3
+fastapi==0.112.2
+numpy==2.1.0
+pandas==2.2.2
+Pillow==10.4.0
+uvicorn==0.30.6
+python-multipart

source/conf.py

@@ -0,0 +1,28 @@
+# Configuration file for the Sphinx documentation builder.
+#
+# For the full list of built-in configuration values, see the documentation:
+# https://www.sphinx-doc.org/en/master/usage/configuration.html
+
+# -- Project information -----------------------------------------------------
+# https://www.sphinx-doc.org/en/master/usage/configuration.html#project-information
+
+project = 'sanjay7178'
+copyright = '2024, sanjay'
+author = 'sanjay'
+release = 'v1'
+
+# -- General configuration ---------------------------------------------------
+# https://www.sphinx-doc.org/en/master/usage/configuration.html#general-configuration
+
+extensions = []
+
+templates_path = ['_templates']
+exclude_patterns = []
+
+
+
+# -- Options for HTML output -------------------------------------------------
+# https://www.sphinx-doc.org/en/master/usage/configuration.html#options-for-html-output
+
+html_theme = 'alabaster'
+html_static_path = ['_static']

source/index.rst

@@ -0,0 +1,17 @@
+.. sanjay7178 documentation master file, created by
+   sphinx-quickstart on Tue Aug 27 20:15:42 2024.
+   You can adapt this file completely to your liking, but it should at least
+   contain the root `toctree` directive.
+
+sanjay7178 documentation
+========================
+
+Add your content using ``reStructuredText`` syntax. See the
+`reStructuredText <https://www.sphinx-doc.org/en/master/usage/restructuredtext/index.html>`_
+documentation for details.
+
+
+.. toctree::
+   :maxdepth: 2
+   :caption: Contents:
+

utils/captcha_solver.py

@@ -0,0 +1,80 @@
+import numpy as np
+from PIL import Image
+import json
+from constants.bitmaps import bitmaps
+import base64
+from io import BytesIO
+
+def pre_img(img):
+    avg = sum(sum(e) for e in img) / (24 * 22)
+    bits = [[1 if val > avg else 0 for val in row] for row in img]
+    return bits
+
+
+def saturation(d):
+    saturate = np.round(((np.max(d, axis=1) - np.min(d, axis=1)) * 255) / np.max(d, axis=1))
+    img = saturate.reshape((40, 200))
+    bls = [img[7 + 5 * (i % 2) + 1:35 - 5 * ((i + 1) % 2), (i + 1) * 25 + 2:(i + 2) * 25 + 1] for i in range(6)]
+    return bls
+
+
+def flatten(arr):
+    return [val for sublist in arr for val in sublist]
+
+
+def mat_mul(a, b):
+    x, z, y = len(a), len(a[0]), len(b[0])
+    product_row = [0] * y
+    product = [[0] * y for _ in range(x)]
+
+    for i in range(x):
+        for j in range(y):
+            for k in range(z):
+                product[i][j] += a[i][k] * b[k][j]
+
+    return product
+
+
+def mat_add(a, b):
+    return [a[i] + b[i] for i in range(len(a))]
+
+
+def max_soft(a):
+    n = list(a)
+    s = sum(np.exp(f) for f in n)
+    n = [np.exp(f) / s for f in n]
+    return n
+
+
+HEIGHT = 40
+WIDTH = 200
+
+def solve(img):
+    weights = None
+    biases = None
+    label_txt = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789"
+    
+    with open("constants/weights.json", "r") as f:
+        data = json.load(f)
+        weights = data["weights"]
+        biases = data["biases"]
+
+    img_data = img.convert("RGB").getdata()
+    img_array = np.array(list(img_data))
+
+    bls = saturation(img_array)
+    out = ""
+
+    for i in range(6):
+        bls[i] = pre_img(bls[i])
+        bls[i] = [flatten(bls[i])]
+        bls[i] = mat_mul(bls[i], weights)
+        bls[i] = mat_add(*bls[i], biases)
+        bls[i] = max_soft(bls[i])
+        index = bls[i].index(max(bls[i]))
+        out += label_txt[index]
+
+    return out
+
+def solve_base64(img_base64: str) -> str:
+    return solve(Image.open(BytesIO(base64.b64decode(img_base64))))

utils/payloads.py

@@ -0,0 +1,72 @@
+import datetime
+
+
+def get_current_time() -> str:
+    return datetime.datetime.now(datetime.timezone.utc).strftime("%c GMT")
+
+
+def get_login_payload(
+    csrf_token: str, username: str, password: str, captcha: str
+) -> dict:
+    return {
+        "_csrf": csrf_token,
+        "username": username,
+        "password": password,
+        "captchaStr": captcha,
+    }
+
+
+def get_profile_payload(username: str, csrf: str) -> dict:
+    return {
+        "verifyMenu": "true",
+        "authorizedID": username,
+        "_csrf": csrf,
+        "nocache": "@(new Date().getTime()",
+    }
+
+
+def get_timetable_payload(username: str, semID: str, csrf: str) -> dict:
+    return {
+        "_csrf": csrf,
+        "semesterSubId": semID,
+        "authorizedID": username,
+        "x": get_current_time(),
+    }
+
+
+def get_attendance_payload(username: str, semID: str, csrf: str) -> dict:
+    return get_timetable_payload(username, semID, csrf)
+
+
+def get_attendance_semID_list_payload(username: str, csrf: str) -> dict:
+    return get_profile_payload(username, csrf)
+
+
+def get_attendance_detail_payload(
+    csrf: str, semID: str, username: str, courseID: str, courseType: str
+) -> dict:
+    return {
+        "_csrf": csrf,
+        "semesterSubId": semID,
+        "registerNumber": username,
+        "courseId": courseID,
+        "courseType": courseType,
+        "authorizedID": username,
+        "x": get_current_time(),
+    }
+
+
+def get_doMarks_view_payload(username: str, semID: str, csrf: str) -> dict:
+    return {"authorizedID": username, "semesterSubId": semID, "_csrf": csrf}
+
+
+def get_gradeHistory_payload(username: str, csrf: str) -> dict:
+    return get_profile_payload(username, csrf)
+
+
+def get_examSchedule_payload(username: str, semID: str, csrf: str) -> dict:
+    return get_doMarks_view_payload(username, semID, csrf)
+
+
+def get_goto_page_payload(username: str, csrf: str) -> dict:
+    return get_profile_payload(username, csrf)

utils/sem_ids.py

@@ -0,0 +1,4 @@
+import json
+import os
+
+semIDs = json.load(open(os.path.join(os.path.dirname(__file__), '../constants/sem_ids.json'))).keys()