### Install OctoDiary Python Library

Source: https://context7.com/octodiary/octodiary-py/llms.txt

Install the stable version of the OctoDiary library using pip. For the latest version from the repository, use the provided URL.

```bash
pip install octodiary --upgrade
```

```bash
pip install https://github.com/OctoDiary/OctoDiary-py/archive/main.zip --upgrade --force-reinstall
```

--------------------------------

### Install Stable OctoDiary-py Version

Source: https://github.com/octodiary/octodiary-py/blob/main/README.md

Installs the latest stable release of the OctoDiary-py library from PyPI. This is recommended for most users who need a reliable version.

```bash
pip install octodiary --upgrade
```

--------------------------------

### Install Latest OctoDiary-py Version

Source: https://github.com/octodiary/octodiary-py/blob/main/README.md

Installs the most recent version of the OctoDiary-py library directly from the main branch of the GitHub repository. Use this command for the newest features or bug fixes.

```bash
pip install https://github.com/OctoDiary/OctoDiary-py/archive/main.zip --upgrade --force-reinstall
```

--------------------------------

### Get School Information (Async)

Source: https://context7.com/octodiary/octodiary-py/llms.txt

Retrieves detailed information about a school using the AsyncMobileAPI. Requires user profile and child school details.

```python
from asyncio import run
from octodiary.apis import AsyncMobileAPI
from octodiary.urls import Systems

async def main():
    api = AsyncMobileAPI(system=Systems.MES)
    api.token = "YOUR_API_TOKEN"

    profiles = await api.get_users_profile_info()
    profile = await api.get_family_profile(profile_id=profiles[0].id)

    child = profile.children[0]

    # Получение информации о школе
    school_info = await api.get_school_info(
        profile_id=profiles[0].id,
        school_id=child.school.id,
        class_unit_id=child.class_unit_id
    )

    print(f"Школа: {school_info.name}")
    print(f"Адрес: {school_info.address}")
    print(f"Телефон: {school_info.phone}")
    print(f"Email: {school_info.email}")
    print(f"Директор: {school_info.principal}")

run(main())
```

--------------------------------

### Fetch Events for Next 7 Days

Source: https://github.com/octodiary/octodiary-py/blob/main/Examples.md

Retrieves a schedule of events for the next 7 days. Requires the student's contingent GUID, user role, and date range.

```python
    # получить расписание событий
    from datetime import date, timedelta

    events = await api.get_events( # получить расписание событий на 7 дней вперед
        person_id=profile.children[0].contingent_guid, # person-id ученика (contingent_guid)
        mes_role=profile.profile.type, # роль пользователя (student, parent)
        begin_date=date.today(), # начало промежутка времени
        end_date=date.today() + timedelta(days=7), # конец
    )
```

--------------------------------

### Retrieve User Profile Information with Async Mobile API

Source: https://context7.com/octodiary/octodiary-py/llms.txt

Fetch user profile information using the Async Mobile API. This includes getting a list of user profiles and detailed family profile information, including children's data.

```python
from asyncio import run
from octodiary.apis import AsyncMobileAPI
from octodiary.urls import Systems

async def main():
    api = AsyncMobileAPI(system=Systems.MYSCHOOL)
    api.token = "YOUR_API_TOKEN"

    # Получение информации о профилях пользователя
    profiles = await api.get_users_profile_info()
    for profile in profiles:
        print(f"ID профиля: {profile.id}")
        print(f"Тип: {profile.type}")

    # Получение семейного профиля
    profile_id = profiles[0].id
    family_profile = await api.get_family_profile(profile_id=profile_id)

    # Вывод информации о детях
    for child in family_profile.children:
        print(f"Ученик: {child.first_name} {child.last_name}")
        print(f"Student ID: {child.id}")
        print(f"Person ID: {child.contingent_guid}")
        print(f"Школа: {child.school.name}")
        print(f"Класс: {child.class_name}")

run(main())
```

--------------------------------

### Fetch Detailed Person Data

Source: https://github.com/octodiary/octodiary-py/blob/main/Examples.md

Retrieves detailed personal data for a student. Requires the student's contingent GUID (person ID) and profile ID.

```python
    # Получить подробную информацию о профиле
    person_data = await api.get_person_data(
        person_id=profile.children[0].contingent_guid, # person-id ученика (contingent_guid)
        profile_id=user_profile_info[0].id             # <PROFILE-ID>
    )
```

--------------------------------

### Get Organization Information

Source: https://github.com/octodiary/octodiary-py/blob/main/Examples.md

Retrieves information about an organization using its ID. The ID is expected to be an 'organization_id'.

```python
    # получить информацию об организации
    ID = person_data.education[0].organization_id # валидный ID организации, именно organization_id
    organization = await api.get_organizations(ID)
```

--------------------------------

### Main Entry Point

Source: https://github.com/octodiary/octodiary-py/blob/main/Examples.md

Handles the selection between web and mobile API modes.

```python
def main():
    type = input("Enter type of api (1 - web, 2 - mobile): ")

    if type == "1":
        web_api()
    else:
        mobile_api()

if __name__ == "__main__":
    main()
```

--------------------------------

### Initialize and Authenticate with MySchool API

Source: https://github.com/octodiary/octodiary-py/blob/main/Examples.md

Sets up the AsyncMobileAPI client and performs authentication via either standard credentials or Gosuslugi.

```python
def mobile_api():
    """
    API методы и запросы, которые делает приложение "Дневник Моя Школа" для получения необходимых данных
    """

    api = AsyncMobileAPI(system=Systems.MYSCHOOL)


    # запрос у пользователя логина и пароля для получения API-Токена
    auth_type = input("Тип авторизации (0 - Логин и пароль, 1 - Госуслуги): ")
    if auth_type == "1": # Авторизация через Госуслуги
        login = input("[Госуслуги] Логин: ")
        password = input("[Госуслуги] Пароль: ")

        api.token = login_gosuslugi(api, login, password) # получение и сохранение API-Токена
    else:
        login = input("Логин: ")
        password = input("Пароль: ")

        api.token = api.login(login, password) # получение и сохранение API-Токена
```

--------------------------------

### Main execution entry point

Source: https://github.com/octodiary/octodiary-py/blob/main/Examples.md

Standard Python boilerplate to execute the mobile API logic.

```python
def main():
    mobile_api()

if __name__ == "__main__":
    main()
```

--------------------------------

### Synchronous API Usage with SyncMobileAPI

Source: https://context7.com/octodiary/octodiary-py/llms.txt

Demonstrates synchronous API calls using SyncMobileAPI, including login, fetching marks, and token refresh. Requires user credentials.

```python
from octodiary.apis import SyncMobileAPI
from octodiary.urls import Systems
from datetime import date, timedelta

# Инициализация синхронного API
api = SyncMobileAPI(system=Systems.MYSCHOOL)
api.token = api.login(username="user@example.com", password="password")

# Получение профиля
profiles = api.get_users_profile_info()
profile = api.get_family_profile(profile_id=profiles[0].id)

student_id = profile.children[0].id
profile_id = profiles[0].id

# Получение оценок
marks = api.get_marks(
    student_id=student_id,
    profile_id=profile_id,
    from_date=date.today() - timedelta(days=7),
    to_date=date.today()
)

for mark in marks.payload:
    print(f"{mark.subject_name}: {mark.value}")

# Обновление токена
api.token = api.refresh_token()
```

--------------------------------

### Web API Interaction in Python

Source: https://github.com/octodiary/octodiary-py/blob/main/Examples.md

Demonstrates various asynchronous API calls to myschool.mosreg.ru using `AsyncWebAPI`. This includes login, token refresh, and fetching user and system data.

```python
async def web_api():
    """
    API методы и запросы, которые делают web-сайты myschool.mosreg.ru и authedu.mosreg.ru
    """

    api = AsyncWebAPI(system=Systems.MYSCHOOL)


    # запрос у пользователя логина и пароля для получения API-Токена
    auth_type = input("Тип авторизации (0 - Логин и пароль, 1 - Госуслуги): ")
    if auth_type == "1": # Авторизация через Госуслуги
        login = input("[Госуслуги] Логин: ")
        password = input("[Госуслуги] Пароль: ")

        api.token = await login_gosuslugi(api, login, password) # получение и сохранение API-Токена
    else:
        login = input("Логин: ")
        password = input("Пароль: ")

        api.token = await api.login(login, password) # получение и сохранение API-Токена

    # получить информацию о пользователе
    user_info = await api.get_user_info()

    # обновить токен
    api.token = await api.refresh_token()

    # получить системные сообщения за текущий день
    system_messages = await api.get_system_messages()

    # получить информацию о сессии и пользователе
    session_info = await api.get_session_info()

    # получить список учебных годов (2022-2023 / 2023-2024)
    academic_years = await api.get_academic_years()


    # получить информацию об одном или нескольких профилях студента (ученика)
    # (оставьте пустым для получения информации о текущем учебном году)
    student_profiles_current_academic_year = await api.get_student_profiles()
    ID = 0 # валидный ID учебного года
    student_profiles = await api.get_student_profiles(academic_year_id=ID) # ID нужно брать из списка учебных годов (см. выше)

    # получить информацию о каком-либо пользователе
    # (оставьте пустым для получения информации о себе)
    owner_user = await api.get_user()
    other_user = await api.get_user("<USER-ID>")


    # получить информацию о web-профиле
    # содержит подробную информацию, включая личные данные
    web_profile = await api.get_family_web_profile()

    # получить полную подробную информацию о пользователе
    person_data = await api.get_person_data("PERSON-ID")

    # получить список событий пользователя
    from datetime import date, timedelta

    events = await api.get_events(
        person_id=web_profile.children[0].contingent_guid, # person-id ученика (contingent_guid)
        mes_role=web_profile.profile.type, # роль пользователя (student, parent)
        begin_date=date.today(), # дата начала (если не указана - текущий день)
        end_date=date.today() + timedelta(days=7), # дата конца (если не указана - текущий день)
    )

    # получить информацию о всех детях пользователя
    # требуется аккаунт родителя
    with suppress(ModuleNotFoundError, ImportError):
        import jwt  # библиотека для декодирования API-токена (pip install pyjwt)

        sso_id = jwt.decode(api.token, verify=False).get("sso")
        childrens = await api.get_children(

```

--------------------------------

### Authenticate and Fetch User Profile Info

Source: https://github.com/octodiary/octodiary-py/blob/main/Examples.md

Handles authentication via login/password or Gosuslugi, then retrieves the user's profile information. Requires user input for credentials.

```python
async def mobile_api():
    """
    API методы и запросы, которые делает приложение "Дневник Моя Школа" для получения необходимых данных
    """

    api = AsyncMobileAPI(system=Systems.MYSCHOOL)


    # запрос у пользователя логина и пароля для получения API-Токена
    auth_type = input("Тип авторизации (0 - Логин и пароль, 1 - Госуслуги): ")
    if auth_type == "1": # Авторизация через Госуслуги
        login = input("[Госуслуги] Логин: ")
        password = input("[Госуслуги] Пароль: ")

        api.token = await login_gosuslugi(api, login, password) # получение и сохранение API-Токена
    else:
        login = input("Логин: ")
        password = input("Пароль: ")

        api.token = await api.login(login, password) # получение и сохранение API-Токена

    # получить информацию о владельце аккаунта, чей токен мы имеем
    user_profile_info = await api.get_users_profile_info()
```

--------------------------------

### Retrieve school and purchase information

Source: https://github.com/octodiary/octodiary-py/blob/main/Examples.md

Fetches daily balance information and general school details.

```python
    # Информация о покупках в школе, буфете, и т.д.
    day_balance_info = api.get_day_balance_info(
        profile_id=profile_id,                          # <PROFILE-ID>
        contract_id=contract_id,                        # <CONTRACT-ID>
    )

    # Получить информацию о школе
    school_info = api.get_school_info(
        profile_id=profile_id,                          # <PROFILE-ID>
        school_id=profile.children[0].school.id,        # <SCHOOL-ID>
        class_unit_id=profile.children[0].class_unit_id # <CLASS-UNIT-ID>
    )
```

--------------------------------

### Authenticate and Fetch Data with AsyncMobileAPI

Source: https://github.com/octodiary/octodiary-py/blob/main/Examples.md

Demonstrates the full flow of authenticating via SMS code and querying various endpoints for student information. Requires valid MESH credentials.

```python
from asyncio import run

from octodiary.apis import AsyncMobileAPI
from octodiary.types.enter_sms_code import EnterSmsCode
from octodiary.urls import Systems


async def mobile_api():
    """
    API методы и запросы, которые делает приложение "Дневник МЭШ" для получения данных
    """

    api = AsyncMobileAPI(system=Systems.MES)

    # авторизовываемся, получаем токен и сохраняем его
    login = input("Логин: ")
    password = input("Пароль: ")

    sms_code: EnterSmsCode = await api.login(username=login, password=password)
    code = input("SMS-Code: ")
    api.token = await sms_code.async_enter_code(code)

    # получаем ID профиля
    profile_id = (await api.get_users_profiles_info())[0].id

    # Получаем инфо о профиле и сохраняем некоторые важные данные, которые будут нужны
    profile = await api.get_family_profile(profile_id=profile_id)
    mes_role = profile.profile.type                      # тип пользователя
    person_id = profile.children[0].contingent_guid      # person-id ученика
    student_id = profile.children[0].id                  # <STUDENT-ID>
    contract_id = profile.children[0].contract_id        # <CONTRACT-ID>

    # получить сохраненные настройки приложения пользователя (тема и т.д.)
    settings = await api.get_user_settings_app(profile_id=profile_id)

    # редактировать настройки приложения у пользователя
    settings.theme.is_automatic = not settings.theme.is_automatic
    await api.edit_user_settings_app(profile_id=profile_id, settings=settings)

    # получить расписание событий
    from datetime import date, timedelta

    events = await api.get_events( # получить расписание событий на 7 дней вперед
        person_id=person_id,                            # person-id ученика (contingent_guid)
        mes_role=mes_role,                              # роль пользователя (student, parent)
        begin_date=date.today(),                        # начало промежутка времени
        end_date=date.today() + timedelta(days=7),      # конец
    )

    # получить краткую информацию о домашних заданиях на 7 дней вперед
    homeworks_short = await api.get_homeworks_short(
        student_id=student_id,                          # <STUDENT-ID>
        profile_id=profile_id,                          # <PROFILE-ID>
        from_date=date.today(),                         # начало промежутка времени
        to_date=date.today() + timedelta(days=7),       # конец
    )

    # получить информацию об оценках за последние 7 дней
    marks = await api.get_marks(
        student_id=student_id,                          # <STUDENT-ID>
        profile_id=profile_id,                          # <PROFILE-ID>
        from_date=date.today() - timedelta(days=7),     # начало промежутка времени
        to_date=date.today(),                           # конец
    )

    # Получить информацию о днях в периоде времени:
    #  - какой учебный модуль идет на момент опеределенного дня
    #  - что это за день: каникулы, выходной, учебный день
    periods_schedules = await api.get_periods_schedules( # информация по дням на 30 дней вперед
        student_id=student_id,                          # <STUDENT-ID>
        profile_id=profile_id,                          # <PROFILE-ID>
        from_date=date.today(),                         # начало промежутка времени
        to_date=date.today() + timedelta(days=30),      # конец
    )

    # Получить список предметов
    subjects = await api.get_subjects(
        student_id=student_id,                          # <STUDENT-ID>
        profile_id=profile_id                           # <PROFILE-ID>
    )

    # получить программу обучения на текущий учебный год
    parallel_curriculum = await api.get_programs_parallel_curriculum(
        id=profile.children[0].parallel_curriculum_id,  # <PARALLEL-CURRICULUM-ID>
        student_id=student_id,                          # <STUDENT-ID>
        profile_id=profile_id                           # <PROFILE-ID>
    )

    # Получить подробную информацию о профиле
    person_data = await api.get_person_data(
        person_id=person_id,                            # person-id ученика (contingent_guid)
        profile_id=profile_id                           # <PROFILE-ID>
    )

    # получить уведомления ученика
    notifications = await api.get_notifications(
        student_id=student_id,                          # <STUDENT-ID>
        profile_id=profile_id                           # <PROFILE-ID>
    )

    # Получить инфо о предмете: оценки и т.д.
    subject_marks_info = await api.get_subject_marks_for_subject(
        student_id=student_id,                          # <STUDENT-ID>
```

--------------------------------

### Fetch Parallel Curriculum Program

Source: https://github.com/octodiary/octodiary-py/blob/main/Examples.md

Retrieves the learning program for the current academic year. Requires parallel curriculum ID, student ID, and profile ID.

```python
    # получить программу обучения на текущий учебный год
    parallel_curriculum = await api.get_programs_parallel_curriculum(
        id=profile.children[0].parallel_curriculum_id, # <PARALLEL-CURRICULUM-ID>
        student_id=profile.children[0].id,             # <STUDENT-ID>
        profile_id=user_profile_info[0].id             # <PROFILE-ID>
    )
```

--------------------------------

### Retrieve balance, marks, and visit information

Source: https://github.com/octodiary/octodiary-py/blob/main/Examples.md

Methods to check account balance, view short-form marks, and track school attendance.

```python
    # Получаем инфо о балансе
    balance_info = api.get_status(
        profile_id=profile_id,                          # <PROFILE-ID>
        contract_id=contract_id                         # <CONTRACT-ID>
    )
    print("Баланс:", balance_info.students[0].balance / 100, "₽")

    # Информация об оценках и средних баллам по предметам
    subject_marks = api.get_subject_marks_short(
        profile_id=profile_id,                          # <PROFILE-ID>
        student_id=student_id                           # <STUDENT-ID>
    )

    # Информация о посещениях (время входа, выхода, и т.д.) за последние 7 дней
    visits = api.get_visits(
        profile_id=profile_id,                          # <PROFILE-ID>
        student_id=student_id,                          # <STUDENT-ID>
        contract_id=contract_id,                        # <CONTRACT-ID>
        from_date=date.today() - timedelta(days=7),     # начало промежутка времени
        to_date=date.today(),                           # конец
    )
```

--------------------------------

### Retrieve User Profile and Settings

Source: https://github.com/octodiary/octodiary-py/blob/main/Examples.md

Fetches profile information and application settings for the authenticated user.

```python
    # получить информацию о владельце аккаунта, чей токен мы имеем
    user_profile_info = api.get_users_profile_info()

    # получить инфо о профиле
    profile = api.get_family_profile(profile_id=user_profile_info[0].id)

    # получить сохраненные настройки приложения пользователя (тема и т.д.)
    settings = api.get_user_settings_app(profile_id=user_profile_info[0].id)

    # редактировать настройки приложения у пользователя
    settings.theme.is_automatic = not settings.theme.is_automatic
    api.edit_user_settings_app(profile_id=user_profile_info[0].id, settings=settings)
```

--------------------------------

### Retrieve Schedule and Events

Source: https://context7.com/octodiary/octodiary-py/llms.txt

Uses get_events() to fetch lessons, marks, and homework for a specified period. Requires a valid API token and system configuration.

```python
from asyncio import run
from datetime import date, timedelta
from octodiary.apis import AsyncMobileAPI
from octodiary.urls import Systems

async def main():
    api = AsyncMobileAPI(system=Systems.MES)
    api.token = "YOUR_API_TOKEN"

    # Получение данных профиля
    profiles = await api.get_users_profile_info()
    profile = await api.get_family_profile(profile_id=profiles[0].id)

    person_id = profile.children[0].contingent_guid
    mes_role = profile.profile.type  # "student" или "parent"

    # Получение расписания на неделю вперед
    events = await api.get_events(
        person_id=person_id,
        mes_role=mes_role,
        begin_date=date.today(),
        end_date=date.today() + timedelta(days=7),
        expand="marks,homework,absence_reason_id,health_status"
    )

    # Вывод расписания
    for event in events.response:
        print(f"\n{event.start_at} - {event.finish_at}")
        print(f"Предмет: {event.subject_name}")
        print(f"Кабинет: {event.room_number}")
        if event.homework:
            print(f"Домашнее задание: {event.homework.description}")
        if event.marks:
            for mark in event.marks:
                print(f"Оценка: {mark.value}")

run(main())
```

--------------------------------

### Fetch Family Profile and App Settings

Source: https://github.com/octodiary/octodiary-py/blob/main/Examples.md

Retrieves the family profile and user application settings. Requires the profile ID obtained from user profile information.

```python
    # получить инфо о профиле
    profile = await api.get_family_profile(profile_id=user_profile_info[0].id)

    # получить сохраненные настройки приложения пользователя (тема и т.д.)
    settings = await api.get_user_settings_app(profile_id=user_profile_info[0].id)
```

--------------------------------

### Async Web API Authentication via Gosuslugi (ESIA)

Source: https://context7.com/octodiary/octodiary-py/llms.txt

Authenticate via Gosuslugi (ESIA) using the Async Web API. Handles MFA and CAPTCHA challenges. If MFA is required, call esia_enter_MFA with the code. For CAPTCHA, either answer the question or verify an image file.

```python
from asyncio import run
from octodiary.apis import AsyncWebAPI
from octodiary.urls import Systems
from octodiary.types.captcha import Captcha

async def handle_captcha(captcha: Captcha, api):
    """Обработка капчи при авторизации"""
    if captcha.question:
        answer = input(captcha.question + ": ")
        return await captcha.async_asnwer_captcha(answer)
    else:
        with open("captcha.png", "wb") as f:
            f.write(captcha.image_bytes)
        answer = input("Введите капчу (captcha.png): ")
        return await captcha.async_verify_captcha(answer)

async def main():
    api = AsyncWebAPI(system=Systems.MYSCHOOL)

    # Авторизация через Госуслуги
    response = await api.esia_login(
        username="user@gosuslugi.ru",
        password="gosuslugi_password"
    )

    if response is False:
        # Требуется MFA (SMS или TOTP)
        code = int(input("Введите код MFA: "))
        api.token = await api.esia_enter_MFA(code=code)
    elif isinstance(response, Captcha):
        # Требуется решить капчу
        api.token = await handle_captcha(response, api)
    else:
        api.token = response

    print(f"Авторизация успешна! Токен: {api.token[:20]}...")

run(main())
```

--------------------------------

### Retrieve Subject and Curriculum Details

Source: https://github.com/octodiary/octodiary-py/blob/main/Examples.md

Fetches subject lists, curriculum programs, and specific subject marks.

```python
    # Получить оценки и средние баллы по предметам за период времени
    marks_short = api.get_subject_marks_short(
        student_id=profile.children[0].id, # <STUDENT-ID>
        profile_id=user_profile_info[0].id # <PROFILE-ID>
    )

    # Получить список предметов
    subjects = api.get_subjects(
        student_id=profile.children[0].id, # <STUDENT-ID>
        profile_id=user_profile_info[0].id # <PROFILE-ID>
    )

    # получить программу обучения на текущий учебный год
    parallel_curriculum = api.get_programs_parallel_curriculum(
        id=profile.children[0].parallel_curriculum_id, # <PARALLEL-CURRICULUM-ID>
        student_id=profile.children[0].id,             # <STUDENT-ID>
        profile_id=user_profile_info[0].id             # <PROFILE-ID>
    )

    # Получить подробную информацию о профиле
    person_data = api.get_person_data(
        person_id=profile.children[0].contingent_guid, # person-id ученика (contingent_guid)
        profile_id=user_profile_info[0].id             # <PROFILE-ID>
    )

    # получить уведомления ученика
    notifications = api.get_notifications(
        student_id=profile.children[0].id, # <STUDENT-ID>
        profile_id=user_profile_info[0].id # <PROFILE-ID>
    )

    # Получить инфо о предмете: оценки и т.д.
    subject_marks_info = api.get_subject_marks_for_subject(
        student_id=profile.children[0].id,   # <STUDENT-ID>
        profile_id=user_profile_info[0].id,  # <PROFILE-ID>
        subject_name="<ИМЯ-ПРЕДМЕТА>"        # Например: "Алгебра"
    )
```

--------------------------------

### Retrieve lesson schedule details

Source: https://context7.com/octodiary/octodiary-py/llms.txt

Fetches detailed information about a specific lesson, including topic, materials, and homework. Requires a valid lesson ID obtained from the schedule.

```python
from asyncio import run
from datetime import date, timedelta
from octodiary.apis import AsyncMobileAPI
from octodiary.urls import Systems

async def main():
    api = AsyncMobileAPI(system=Systems.MES)
    api.token = "YOUR_API_TOKEN"

    profiles = await api.get_users_profile_info()
    profile = await api.get_family_profile(profile_id=profiles[0].id)

    # Сначала получаем расписание
    events = await api.get_events(
        person_id=profile.children[0].contingent_guid,
        mes_role=profile.profile.type,
        begin_date=date.today(),
        end_date=date.today() + timedelta(days=1)
    )

    # Получение детальной информации о первом уроке
    if events.response:
        lesson = await api.get_lesson_schedule_item(
            profile_id=profiles[0].id,
            lesson_id=events.response[0].id,
            student_id=profile.children[0].id,
            type=events.response[0].source  # "PLAN" или "FACT"
        )

        print(f"Предмет: {lesson.subject_name}")
        print(f"Тема: {lesson.lesson_topic}")
        print(f"Учитель: {lesson.teacher_name}")
        if lesson.homework:
            print(f"Домашнее задание: {lesson.homework.description}")

run(main())
```

--------------------------------

### Retrieve student schedule and period information

Source: https://github.com/octodiary/octodiary-py/blob/main/Examples.md

Fetches schedule data for a specific date range and retrieves detailed information about school days, including holidays and modules.

```python
        profile_id=profile_id,                          # <PROFILE-ID>
        from_date=date.today() - timedelta(days=7),     # начало промежутка времени
        to_date=date.today(),                           # конец
    )

    # Получить информацию о днях в периоде времени:
    #  - какой учебный модуль идет на момент опеределенного дня
    #  - что это за день: каникулы, выходной, учебный день
    periods_schedules = api.get_periods_schedules( # информация по дням на 30 дней вперед
        student_id=student_id,                          # <STUDENT-ID>
        profile_id=profile_id,                          # <PROFILE-ID>
        from_date=date.today(),                         # начало промежутка времени
        to_date=date.today() + timedelta(days=30),      # конец
    )
```

--------------------------------

### Retrieve subject marks and lesson details

Source: https://github.com/octodiary/octodiary-py/blob/main/Examples.md

Fetches specific subject marks and detailed information about a particular lesson or activity.

```python
    # Получить инфо о предмете: оценки и т.д.
    subject_marks_info = api.get_subject_marks_for_subject(
        student_id=student_id,                          # <STUDENT-ID>
        profile_id=profile_id,                          # <PROFILE-ID>
        subject_name="<ИМЯ-ПРЕДМЕТА>"                   # Например: "Алгебра"
    )

    # Получим подробную информацию об уроке или занятии (в данном случае о первом занятии в списке)
    lesson_info = api.get_lesson_schedule_item(
        profile_id=profile_id,                          # <PROFILE-ID>
        lesson_id=events.response[0].id,                # <LESSON-ID>
        student_id=student_id,                          # <STUDENT-ID>
        type=events.response[0].source                  # <TYPE>
    )
```

--------------------------------

### Fetch Period Schedules for 30 Days

Source: https://github.com/octodiary/octodiary-py/blob/main/Examples.md

Retrieves information about school days, including learning modules and day types (holidays, weekends, school days) for the next 30 days. Requires student ID, profile ID, and date range.

```python
    # Получить информацию о днях в периоде времени:
    #  - какой учебный модуль идет на момент опеределенного дня
    #  - что это за день: каникулы, выходной, учебный день
    periods_schedules = await api.get_periods_schedules( # информация по дням на 30 дней вперед
        student_id=profile.children[0].id,              # <STUDENT-ID>
        profile_id=user_profile_info[0].id,             # <PROFILE-ID>
        from_date=date.today(),                         # начало промежутка времени
        to_date=date.today() + timedelta(days=30),      # конец
    )
```

--------------------------------

### Fetch Short Homeworks for Next 7 Days

Source: https://github.com/octodiary/octodiary-py/blob/main/Examples.md

Retrieves a summary of homework assignments for the next 7 days. Requires student ID, profile ID, and date range.

```python
    # получить краткую информацию о домашних заданиях на 7 дней вперед
    homeworks_short = await api.get_homeworks_short(
        student_id=profile.children[0].id, # <STUDENT-ID>
        profile_id=user_profile_info[0].id, # <PROFILE-ID>
        from_date=date.today(), # начало промежутка времени
        to_date=date.today() + timedelta(days=7), # конец
    )
```

--------------------------------

### Fetch List of Subjects

Source: https://github.com/octodiary/octodiary-py/blob/main/Examples.md

Retrieves a list of all subjects for a student. Requires student ID and profile ID.

```python
    # Получить список предметов
    subjects = await api.get_subjects(
        student_id=profile.children[0].id, # <STUDENT-ID>
        profile_id=user_profile_info[0].id # <PROFILE-ID>
    )
```

--------------------------------

### Async Mobile API Authentication with Login/Password

Source: https://context7.com/octodiary/octodiary-py/llms.txt

Authenticate using a username and password with the Async Mobile API. For the MESH system, SMS verification is required. The token is returned upon successful login.

```python
from asyncio import run
from octodiary.apis import AsyncMobileAPI
from octodiary.urls import Systems
from octodiary.types.enter_sms_code import EnterSmsCode

async def main():
    # Инициализация API для системы Моя Школа
    api = AsyncMobileAPI(system=Systems.MYSCHOOL)

    # Авторизация с логином и паролем
    api.token = await api.login(
        username="user@example.com",
        password="your_password"
    )
    print(f"Токен получен: {api.token[:20]}...")

    # Для системы МЭШ требуется SMS-код
    api_mes = AsyncMobileAPI(system=Systems.MES)
    sms_code_obj: EnterSmsCode = await api_mes.login(
        username="+79001234567",
        password="password123"
    )

    # Ввод SMS-кода для завершения авторизации
    code = input("Введите SMS-код: ")
    api_mes.token = await sms_code_obj.async_enter_code(code)

run(main())
```

--------------------------------

### Retrieve meal balance and purchase history

Source: https://context7.com/octodiary/octodiary-py/llms.txt

Fetches the current card balance and recent cafeteria purchase history for the student.

```python
from asyncio import run
from octodiary.apis import AsyncMobileAPI
from octodiary.urls import Systems

async def main():
    api = AsyncMobileAPI(system=Systems.MES)
    api.token = "YOUR_API_TOKEN"

    profiles = await api.get_users_profile_info()
    profile = await api.get_family_profile(profile_id=profiles[0].id)

    contract_id = profile.children[0].contract_id

    # Получение баланса
    status = await api.get_status(
        profile_id=profiles[0].id,
        contract_ids=contract_id
    )

    print(f"Баланс: {status.students[0].balance / 100} ₽")

    # Получение истории покупок
    day_balance = await api.get_day_balance_info(
        profile_id=profiles[0].id,
        contract_id=contract_id,
        first=14  # последние 14 записей
    )

    for item in day_balance.payload:
        print(f"{item.date}: {item.title} - {item.amount / 100} ₽")

run(main())
```

--------------------------------

### Login to Gosuslugi with MFA in Python

Source: https://github.com/octodiary/octodiary-py/blob/main/Examples.md

Handles login to Gosuslugi, supporting both password-based and MFA-protected logins. It uses the `handle_captcha` function for CAPTCHA resolution if necessary.

```python
async def login_gosuslugi(
    api: AsyncWebAPI | AsyncMobileAPI,
    login: str,
    password: str
):
    response: bool | Captcha = await api.esia_login(login, password)
    if isinstance(response, bool): # Требуется MFA код
        code_mfa = int(input("MFA Code: ").strip()) # запрашиваем у пользователя код (SMS/TOTP)
        response2 = await api.esia_enter_MFA(code=code_mfa)
        token = response2 if isinstance(response2, str) else await handle_captcha(response2)
    elif isinstance(response, Captcha): # Капча
        token = await handle_captcha(response)

    return token
```

--------------------------------

### Web API Operations (Async)

Source: https://context7.com/octodiary/octodiary-py/llms.txt

Utilizes AsyncWebAPI to interact with the web version of the diary, fetching user info, academic years, messages, and events.

```python
from asyncio import run
from octodiary.apis import AsyncWebAPI
from octodiary.urls import Systems
from datetime import date, timedelta

async def main():
    api = AsyncWebAPI(system=Systems.MYSCHOOL)
    api.token = "YOUR_API_TOKEN"

    # Получение информации о пользователе
    user_info = await api.get_user_info()
    print(f"Пользователь: {user_info.first_name} {user_info.last_name}")

    # Получение списка учебных годов
    academic_years = await api.get_academic_years()
    for year in academic_years:
        print(f"{year.name}: {year.begin_date} - {year.end_date}")

    # Получение системных сообщений
    messages = await api.get_system_messages(published=True, today=True)
    for msg in messages:
        print(f"Сообщение: {msg.get('text', '')}")

    # Получение веб-профиля семьи
    web_profile = await api.get_family_web_profile()
    for child in web_profile.children:
        print(f"Ученик: {child.first_name} {child.last_name}")

    # Получение расписания через Web API
    events = await api.get_events(
        person_id=web_profile.children[0].contingent_guid,
        mes_role=web_profile.profile.type,
        begin_date=date.today(),
        end_date=date.today() + timedelta(days=7)
    )

run(main())
```

--------------------------------

### Fetch Academic Data and Schedules

Source: https://github.com/octodiary/octodiary-py/blob/main/Examples.md

Retrieves events, homework, marks, and academic periods for a student.

```python
    # получить расписание событий
    from datetime import date, timedelta

    events = api.get_events( # получить расписание событий на 7 дней вперед
        person_id=profile.children[0].contingent_guid, # person-id ученика (contingent_guid)
        mes_role=profile.profile.type, # роль пользователя (student, parent)
        begin_date=date.today(), # начало промежутка времени
        end_date=date.today() + timedelta(days=7), # конец
    )

    # получить краткую информацию о домашних заданиях на 7 дней вперед
    homeworks_short = api.get_homeworks_short(
        student_id=profile.children[0].id, # <STUDENT-ID>
        profile_id=user_profile_info[0].id, # <PROFILE-ID>
        from_date=date.today(), # начало промежутка времени
        to_date=date.today() + timedelta(days=7), # конец
    )

    # получить информацию об оценках за последние 7 дней
    marks = api.get_marks(
        student_id=profile.children[0].id, # <STUDENT-ID>
        profile_id=user_profile_info[0].id, # <PROFILE-ID>
        from_date=date.today() - timedelta(days=7), # начало промежутка времени
        to_date=date.today(), # конец
    )

    # Получить информацию о днях в периоде времени:
    #  - какой учебный модуль идет на момент опеределенного дня
    #  - что это за день: каникулы, выходной, учебный день
    periods_schedules = api.get_periods_schedules( # информация по дням на 30 дней вперед
        student_id=profile.children[0].id,              # <STUDENT-ID>
        profile_id=user_profile_info[0].id,             # <PROFILE-ID>
        from_date=date.today(),                         # начало промежутка времени
        to_date=date.today() + timedelta(days=30),      # конец
    )
```

--------------------------------

### Retrieve academic and profile data

Source: https://github.com/octodiary/octodiary-py/blob/main/Examples.md

Methods to fetch subjects, curriculum programs, personal data, and student notifications.

```python
    # Получить список предметов
    subjects = api.get_subjects(
        student_id=student_id,                          # <STUDENT-ID>
        profile_id=profile_id                           # <PROFILE-ID>
    )

    # получить программу обучения на текущий учебный год
    parallel_curriculum = api.get_programs_parallel_curriculum(
        id=profile.children[0].parallel_curriculum_id,  # <PARALLEL-CURRICULUM-ID>
        student_id=student_id,                          # <STUDENT-ID>
        profile_id=profile_id                           # <PROFILE-ID>
    )

    # Получить подробную информацию о профиле
    person_data = api.get_person_data(
        person_id=person_id,                            # person-id ученика (contingent_guid)
        profile_id=profile_id                           # <PROFILE-ID>
    )

    # получить уведомления ученика
    notifications = api.get_notifications(
        student_id=student_id,                          # <STUDENT-ID>
        profile_id=profile_id                           # <PROFILE-ID>
    )
```

--------------------------------

### Retrieve Grades and Averages

Source: https://context7.com/octodiary/octodiary-py/llms.txt

Fetches individual grades via get_marks() and subject averages via get_subject_marks_short().

```python
from asyncio import run
from datetime import date, timedelta
from octodiary.apis import AsyncMobileAPI
from octodiary.urls import Systems

async def main():
    api = AsyncMobileAPI(system=Systems.MES)
    api.token = "YOUR_API_TOKEN"

    profiles = await api.get_users_profile_info()
    profile = await api.get_family_profile(profile_id=profiles[0].id)

    student_id = profile.children[0].id
    profile_id = profiles[0].id

    # Получение оценок за последние 7 дней
    marks = await api.get_marks(
        student_id=student_id,
        profile_id=profile_id,
        from_date=date.today() - timedelta(days=7),
        to_date=date.today()
    )

    for mark in marks.payload:
        print(f"Предмет: {mark.subject_name}")
        print(f"Оценка: {mark.value} ({mark.weight} вес)")
        print(f"Комментарий: {mark.comment}")
        print(f"Дата: {mark.date}")
        print("---")

    # Получение средних баллов по предметам
    subject_marks = await api.get_subject_marks_short(
        student_id=student_id,
        profile_id=profile_id
    )

    for subject in subject_marks.payload:
        print(f"{subject.subject_name}: {subject.average_mark:.2f}")

run(main())
```

--------------------------------

### API Type Selection

Source: https://github.com/octodiary/octodiary-py/blob/main/Examples.md

Prompts the user to select the type of API to use (web or mobile).

```python
async def main():
    type = input("Enter type of api (1 - web, 2 - mobile): ")
```