Создание проекта с использованием модулей и фреймворков.

Содержание

Виртуальное окружение
Инструменты для создания виртуального окружения в Python
Порядок работы с виртуальным окружением через venv
Модуль в Python
Установка модулей и фреймворков с помощью pip
Пакеты в проекте и организация папок проекта
Пакет
Особенности и отличия модулей от пакетов
Что содержится в init.py
Импорты
Примеры импортов пакета, модулей пакета, подмодулей и подпакетов.
Создание структуры проекта
Структура Проекта.
Как создать распространяемый пакет
Шаг 1: Структура проекта
Шаг 2: Создание setup.py
Шаг 3: Описание зависимостей
Шаг 4: Добавление README
Шаг 5: Упаковка и распространение
Шаг 6: Публикация на PyPI
Шаг 7: Установка вашего пакета
Editable режим пакета
Запись конфигурации проекта
INI-файлы (например, config.ini):
Пример использования в Python:
JSON-файлы (например, config.json):
Пример использования в Python:
Python-модуль (например, settings.py):
Пример использования в Python:
4. Переменные окружения:
Важные рекомендации:
Пример организации проекта.
Структура проекта
Объяснение структуры:
Рекомендации:

Виртуальное окружение

С чего начать свой проект? С создания изоляции проекта с помощью виртуального окружения.

Виртуальное окружение — это инструмент в Python, который позволяет создавать изолированные среды для работы с проектами.

Каждое виртуальное окружение содержит собственную установленную копию интерпретатора Python и набор библиотек и модулей. Это позволяет изолировать зависимости проекта от глобальных установок Python и других проектов.

Почему важно изолировать проект:

Избежание конфликтов зависимостей: Разные проекты могут требовать различные версии библиотек и модулей. Использование виртуальных окружений позволяет избежать конфликтов между версиями и обеспечивает работоспособность каждого проекта в его собственной изолированной среде.
Чистота и портативность: Виртуальное окружение создает чистую и портативную среду, что облегчает передачу проекта между разработчиками и запуск на различных платформах. Проект будет работать в том виде, в котором был разработан, даже если у пользователя установлены другие версии библиотек.
Эффективное управление зависимостями: Использование виртуальных окружений позволяет точно определить зависимости проекта, что полезно при развертывании проекта на новом сервере или обновлении зависимостей в разработке.
Изоляция от глобальных изменений: Иногда необходимо экспериментировать с новыми версиями библиотек или фреймворков без влияния на другие проекты или системные компоненты. Виртуальные окружения предоставляют контроль над изменениями, применяемыми только к конкретному проекту.
Безопасность: Использование виртуальных окружений помогает избежать ошибок и несанкционированного вмешательства в глобальные системные библиотеки и модули.

Инструменты для создания виртуального окружения в Python

Существует несколько популярных инструментов для управления виртуальными окружениями в Python. Каждый из них имеет свои особенности, и выбор зависит от предпочтений и требований разработчика. Вот несколько из них:

virtualenv:

Описание: Это один из наиболее широко используемых инструментов для создания виртуальных окружений.
Преимущества:
- Легкий в использовании.
- Поддерживает Python 2 и Python 3.

Использование:

# Установка virtualenv
pip install virtualenv

# Создание виртуального окружения
virtualenv myenv

# Активация виртуального окружения (Linux/Mac)
source myenv/bin/activate

# Активация виртуального окружения (Windows)
.\myenv\Scripts\activate

venv:
- Описание: Входит в стандартную библиотеку Python и предоставляет аналогичные функции virtualenv.
- Преимущества:
  - Встроен в Python 3.3 и более поздние версии.
- Использование:
```
# Создание виртуального окружения
python -m venv myenv

# Активация виртуального окружения (Linux/Mac)
source myenv/bin/activate

# Активация виртуального окружения (Windows)
.\myenv\Scripts\activate
```
conda:
- Описание: Conda является пакетным менеджером и системой управления окружениями для Python и других языков программирования.
- Преимущества:
  - Управление не только Python, но и библиотеками на C, C++, R, Ruby, LUA и другими языками.
  - Позволяет создавать окружения с зависимостями не только из PyPI, но и из других источников.
- Использование:
```
# Создание виртуального окружения
conda create --name myenv

# Активация виртуального окружения
conda activate myenv
```

Порядок работы с виртуальным окружением через `venv`

Установка venv (если ещё не установлен):
```
python -m venv myenv
```
Эта команда создаст каталог myenv, содержащий файлы и структуру каталогов для нового виртуального окружения.
Активация виртуального окружения:
- Linux/Mac:
```
source myenv/bin/activate
```
- Windows:
```
.\myenv\Scripts\activate
```
При успешной активации вы увидите префикс с именем вашего виртуального окружения в командной строке.

Деактивация виртуального окружения:

deactivate

Эта команда деактивирует текущее виртуальное окружение и возвращает вас к системному Python.

Изменение виртуального окружения:

Установка дополнительных пакетов:
```
pip install package_name
```
Эта команда устанавливает пакет в вашем активированном виртуальном окружении.
Удаление пакетов:
```
pip uninstall package_name
```
Эта команда удаляет пакет из вашего виртуального окружения.
Обновление pip (пакетного менеджера):
```
pip install --upgrade pip
```
Эта команда обновляет pip до последней версии.

Работа с файлом зависимостей (requirements.txt):

Создание файла зависимостей:
```
pip freeze > requirements.txt
```
Эта команда сохраняет список установленных пакетов и их версий в файл requirements.txt.
Установка зависимостей из файла:
```
pip install -r requirements.txt
```
Эта команда устанавливает все пакеты и их версии, указанные в файле requirements.txt.

Модуль в Python

В Python термин «модуль» относится к файлу, содержащему код на Python.

Этот файл может содержать определения переменных, функций и классов, а также выполнимый код. Модули в Python используются для организации кода и упрощения его повторного использования. Вы можете импортировать модули в другие файлы и использовать их содержимое.

Пример простого модуля:

# Модуль example_module.py

def say_hello(name):
    print(f"Hello, {name}!")

# Выполняемый код
if __name__ == "__main__":
    say_hello("World")

Модуль можно затем импортировать в другом файле Python:

# Использование модуля
import example_module

example_module.say_hello("Alice")

Установка модулей и фреймворков с помощью `pip`

pip (Package Installer for Python)pip — это инструмент для установки пакетов в Python.

Он является стандартным пакетным менеджером, который упрощает процесс установки, обновления и удаления пакетов из Python Package Index (PyPI). PyPI — это репозиторий, в котором разработчики Python публикуют свои пакеты, которые могут быть установлены с использованием pip.

Установка модуля:
```
pip install module_name
```
Эта команда устанавливает модуль с именем module_name в вашем активированном виртуальном окружении.
Установка конкретной версии модуля:
```
pip install module_name==1.2.3
```
Эта команда устанавливает конкретную версию модуля. Замените 1.2.3 на нужную версию.
Установка модулей из файла зависимостей (requirements.txt):
```
pip install -r requirements.txt
```
Эта команда устанавливает все модули и их версии, указанные в файле requirements.txt.

Деинсталляция модулей:

pip uninstall module_name

Эта команда удаляет модуль с именем module_name из вашего виртуального окружения.

Просмотр установленных модулей:

pip list

Эта команда выводит список всех установленных модулей в вашем виртуальном окружении.

Настройка зависимостей модулей:

Создание файла зависимостей (requirements.txt):
```
pip freeze > requirements.txt
```
Эта команда сохраняет текущий список установленных модулей в файл requirements.txt.
Редактирование файла зависимостей: Отредактируйте файл requirements.txt, добавив/удаляя модули и их версии по вашему выбору.
Установка зависимостей из файла:
```
pip install -r requirements.txt
```
Эта команда устанавливает модули и их версии из файла requirements.txt.

Управление зависимостями при конкретных версиях:

Установка версии модуля в файле зависимостей:
```
pip freeze > requirements.txt
```
Эта команда сохранит версии всех установленных модулей в файл requirements.txt.
Использование конкретных версий при установке:
```
pip install -r requirements.txt
```
Эта команда установит модули с версиями, указанными в файле requirements.txt.

Зачем нужен файл зависимостей:

Репродуцируемость проекта: Файл зависимостей позволяет другим разработчикам и системам точно воссоздать среду вашего проекта.
Управление версиями: Он помогает фиксировать версии зависимостей, что важно для избегания неожиданных обновлений, которые могут сломать ваш проект.
Публикация проекта: При публикации проекта, файл зависимостей предоставляет информацию о том, какие версии библиотек поддерживают ваш проект.

Пакеты в проекте и организация папок проекта

Пакет

В Python термин «пакет» относится к специальному виду организации файлов и папок, который позволяет структурировать и организовать код внутри проекта. Пакет представляет собой каталог, в котором есть файл __init__.py, который может быть пустым или содержать код инициализации.

Основные характеристики пакета в Python:

Каталог с __init__.py: Пакет всегда является каталогом, в котором есть файл __init__.py. Этот файл может быть пустым, но его наличие указывает Python, что данный каталог следует рассматривать как пакет.
Иерархия вложенности: Пакеты могут вкладываться друг в друга, образуя иерархию. Каждый подкаталог с файлом __init__.py считается пакетом.
Организация кода: Пакеты используются для логической организации кода. Они позволяют группировать связанные модули в одном месте.
```
my_package/
|-- __init__.py
|-- module1.py
|-- module2.py
|-- subpackage/
|   |-- __init__.py
|   |-- submodule1.py
|   |-- submodule2.py
```

В данном примере:

my_package — это основной пакет.
__init__.py — файл, указывающий, что my_package — это пакет.
module1.py и module2.py — модули, принадлежащие пакету.
subpackage — вложенный пакет в my_package.
submodule1.py и submodule2.py — модули, принадлежащие подпакету.

Использование пакетов помогает структурировать проект, делает код более модульным и обеспечивает лучшую организацию для повторного использования кода.

Особенности и отличия модулей от пакетов

Иерархия:
- Модуль: Обычно это одиночный файл с кодом на Python.
- Пакет: Это каталог, содержащий один или более файлов модулей и файл __init__.py. Пакеты могут также вкладываться друг в друга, образуя иерархию.
Организация кода:
- Модуль: Используется для группировки кода внутри одного файла.
- Пакет: Используется для логической группировки связанных модулей, обеспечивая более сложную структуру проекта.
Использование:
- Модуль: Импортируется в других файлах для использования его содержимого.
- Пакет: Импортируется для доступа к модулям внутри него. Импорт пакета также может выполнять код из файла __init__.py.
Пример:
- Модуль: module.py
- Пакет: my_package/ с файлами __init__.py, module1.py, module2.py

Важно помнить, что пакет — это более высокоуровневая структура, позволяющая более удобно организовывать и структурировать код в больших проектах.

Что содержится в `init.py`

Файл __init__.py в каталоге Python является специальным файлом, который указывает Python, что данный каталог следует рассматривать как пакет. Этот файл может быть пустым, или он может содержать код инициализации, который выполняется при импорте пакета. Важно отметить, что наличие файла __init__.py необходимо для того, чтобы Python рассматривал каталог как пакет.

Пример пустого __init__.py:

# Пустой __init__.py

Пример __init__.py с кодом инициализации:

# __init__.py с кодом инициализации

print("Этот код выполняется при импорте пакета")

Когда вы импортируете пакет в свой код, код в файле __init__.py выполняется:

import my_package  # Выведет "Этот код выполняется при импорте пакета"

__init__.py может содержать различные вещи, включая:

Код инициализации: Вы можете использовать __init__.py для выполнения кода, который нужен при импорте пакета.
Определение переменных и констант: Если ваш пакет предоставляет какие-то общие переменные, вы можете определить их в __init__.py.
Импорт подмодулей: Вы можете импортировать подмодули в __init__.py, чтобы сделать их доступными при импорте пакета.

Пример с импортом подмодуля в __init__.py:

# __init__.py с импортом подмодуля

from . import module1
from . import module2

# Когда вы импортируете пакет, module1 и module2 будут доступны

Импорты

Импорт в Python — это механизм, который позволяет вам использовать код из других модулей или библиотек в своем собственном коде. Он позволяет структурировать код, делать его более читаемым и управляемым, а также повторно использовать функции и классы.

Пример простого импорта:

# Импорт всего модуля
import math

# Использование функции из модуля
result = math.sqrt(25)
print(result)

Различия между абсолютным и относительным импортом:

Абсолютный импорт:
- Импортирует модуль с использованием полного пути от корня проекта.
- Используется с ключевым словом import.
- Пример:
```
from mypackage import mymodule
```
Относительный импорт:
- Импортирует модуль относительно текущего модуля.
- Используется с ключевыми словами from и import.
- Примеры:
```
from . import mymodule         # Относительный импорт текущего пакета
from .. import anothermodule   # Относительный импорт родительского пакета
```

Примеры импорта модулей из внешних и собственных пакетов:

Импорт из внешнего (стороннего) пакета:
- Вам необходимо установить пакет с помощью pip перед его использованием.
- Пример:
```
# Установка стороннего пакета
# pip install requests

# Импорт модуля из стороннего пакета
import requests
```

Импорт из собственного пакета:

Пакет — это каталог, в котором есть файл __init__.py, а модуль — это файл с расширением .py.

Примеры:

# Пакет: mypackage
# Модуль: mymodule.py

# Импорт из собственного модуля
from mypackage import mymodule

# Импорт из собственного пакета
import mypackage.anothermodule

Примеры импортов пакета, модулей пакета, подмодулей и подпакетов.

Дана структура модулей и пакетов:

my_package/
|-- __init__.py
|-- module1.py
|-- module2.py
|-- subpackage/
|   |-- __init__.py
|   |-- submodule1.py
|   |-- submodule2.py

Предположим, вы находитесь в файле, который находится на том же уровне, что и ваш пакет my_package. Давайте рассмотрим, как импортировать модуль, пакет, субмодуль и субпакет:

Импортирование модуля:

# Ваш файл находится на том же уровне, что и my_package
from my_package import module1
module1.some_function()

Импортирование пакета:

# Ваш файл находится на том же уровне, что и my_package
import my_package
my_package.some_function_from_init()  # Вызов функции из __init__.py, если такая есть

Импортирование субмодуля из пакета:

# Ваш файл находится на том же уровне, что и my_package
from my_package.subpackage import submodule1
submodule1.some_function()

Импортирование субпакета из пакета:

# Ваш файл находится на том же уровне, что и my_package
from my_package import subpackage
subpackage.some_function_from_init()  # Вызов функции из __init__.py в субпакете, если такая есть

Создание структуры проекта

Импорт модулей:

Когда вы импортируете модуль в свой код, Python решает, как найти этот модуль. Это зависит от того, как запускается ваш код. При поиске Python использует переменную sys.path, которая содержит пути для поиска модулей.

Стандартные пути включают:

Каталог, откуда запускается скрипт.
Пути, указанные в переменной окружения PYTHONPATH.
Каталог текущего виртуального окружения.
Каталог установки Python.

Структура Проекта.

Именование файлов и каталогов. Будьте внимательны при именовании модулей и пакетов, чтобы избежать конфликтов имен с встроенными или сторонними модулями.
Создание пакета:
```
├── myproject
│   ├── __init__.py
│   ├── module1.py
│   └── module2.py
├── scripts
│   └── run_script.py
└── requirements.txt
```
Рекомендуется упаковывать код в пакет с уникальным именем. Это помогает избежать конфликтов имен.
Структура для запускаемых скриптов: Если у вас есть запускаемые скрипты, вы можете вынести их на верхний уровень, а остальной код упаковать в пакет. Это делает структуру sys.path более предсказуемой.
```
├── myproject
│   ├── __init__.py
│   ├── module1.py
│   └── module2.py
├── run_script.py
└── requirements.txt
```
Создание распространяемого пакета (рекомендуется):
```
├── pyproject.toml
└── src
    └── myproject
        ├── __init__.py
        ├── module1.py
        └── module2.py
```
Упаковка всего кода в пакет делает структуру еще более чистой. Используйте структуру с исходным кодом в каталоге «src»:

Использование pip для установки:

Для удобства разработки, установите пакет в «editable» режиме:

pip install -e .

Теперь, будучи в любом каталоге, вы можете запускать код, не указывая полные пути к файлам.

Соблюдение этих простых принципов при организации импортов и структуры проекта поможет вам избежать проблем с именами, сделает ваш код более читаемым и поддерживаемым, что особенно важно, начиная свой первый проект на Python.

Как создать распространяемый пакет

Создание распространяемого (дистрибутируемого) пакета в Python — это процесс упаковки вашего кода в формат, который может быть легко распространен и установлен другими пользователями или проектами.

Распространяемые пакеты обычно создаются с использованием инструментов, таких как setuptools и wheel, и затем могут быть опубликованы на публичных репозиториях, таких как PyPI.

Пошаговое руководство по созданию распространяемого пакета:

Шаг 1: Структура проекта

Ваш проект должен иметь определенную структуру для создания дистрибутируемого пакета. Например:

my_project/
|-- my_package/
|   |-- __init__.py
|   |-- module1.py
|   |-- module2.py
|-- setup.py
|-- README.md

Шаг 2: Создание `setup.py`

setup.py — это файл, который содержит информацию о вашем проекте и используется для настройки параметров установки.

Пример setup.py:

from setuptools import setup, find_packages

setup(
    name='my-package',
    version='0.1',
    packages=find_packages(),
    install_requires=[
        # Список зависимостей вашего проекта
    ],
    entry_points={
        'console_scripts': [
            'my-command = my_package.module1:main',  # Пример добавления команды в консоль
        ],
    },
)

Шаг 3: Описание зависимостей

В разделе install_requires указываются зависимости вашего проекта. Это модули или пакеты, которые необходимы для корректной работы вашего кода. Когда ваш пакет устанавливается с помощью pip, эти зависимости также будут установлены.

Шаг 4: Добавление README

Хорошо написанный README.md поможет другим пользователям быстро понять, как использовать ваш пакет. Это также становится основой для документации.

Шаг 5: Упаковка и распространение

Откройте терминал в корневом каталоге вашего проекта.
Убедитесь, что у вас установлен setuptools и wheel:
```
pip install setuptools wheel
```
Создайте дистрибутив.
```
python setup.py sdist bdist_wheel
```
Это создаст исходный дистрибутив (sdist) и бинарный (bdist_wheel).
Результат будет в папке dist. В этой папке будут файлы с расширениями .tar.gz и .whl.

Шаг 6: Публикация на PyPI

Зарегистрируйтесь на PyPI (если вы еще этого не сделали).
Установите twine:
```
pip install twine
```
Это позволит другим пользователям устанавливать ваш пакет с использованием pip.

Шаг 7: Установка вашего пакета

Теперь другие пользователи могут устанавливать ваш пакет с помощью:

pip install my-package

Editable режим пакета

Установка пакета в «editable» режим, также известного как «режим разработки» или «режим редактирования», позволяет вам работать с кодом пакета прямо из его исходного кода, а не из установленной версии. Это очень полезно во время разработки, поскольку вы можете вносить изменения в код и тут же видеть результаты без необходимости переустановки пакета.

Чтобы установить пакет в «editable» режиме, используйте флаг -e с командой pip install. Вот пример:

pip install -e /путь/к/вашему/пакету

или, если вы находитесь в каталоге с setup.py, можно использовать текущий каталог:

pip install -e .

После установки пакета в «editable» режиме, его исходный код становится «живым». Это означает, что изменения, внесенные в код пакета, сразу же отражаются в работающем коде без необходимости повторной установки. Это может быть особенно удобно, если вы работаете над несколькими проектами или модулями и хотите видеть изменения в режиме реального времени.

В «editable» режиме pip создает символическую ссылку или файл .pth в каталоге установки, указывающий на исходный код вашего пакета, вместо того чтобы копировать его. Таким образом, когда вы вносите изменения в исходный код, они сразу же становятся доступными для всех проектов, использующих этот пакет.

Преимущества установки в «editable» режиме:

Мгновенные изменения: Вы видите результаты ваших изменений в коде немедленно.
Удобство разработки: Отлично подходит для разработки и тестирования, особенно когда вы работаете над несколькими связанными проектами.
Совместное использование кода: Если у вас есть общий код, который используется в нескольких проектах, «editable» режим позволяет вам вносить изменения и сразу видеть, как они влияют на другие проекты.
Легкость отладки: Вы можете добавить отладочные инструкции, изменить логику и сразу же видеть результаты без необходимости переустановки.

Однако следует быть осторожным с этим режимом, особенно при работе с крупными проектами или когда вам нужно иметь точную контрольную версию пакета в различных окружениях. В таких случаях, рекомендуется периодически фиксировать версию пакета и использовать стандартную установку.

Запись конфигурации проекта

Запись конфигурации проекта в файл – это важная часть разработки программного обеспечения, которая позволяет изолировать настройки проекта от исходного кода. Это делает конфигурацию более гибкой и позволяет изменять параметры без необходимости внесения изменений в код. Есть несколько распространенных способов организации конфигураций:

INI-файлы (например, config.ini):

INI-файлы представляют собой текстовые файлы, содержащие разделы, параметры и их значения. Пример config.ini:

[Database]
host = localhost
port = 5432
username = user
password = password123

[API]
key = your_api_key
url = https://api.example.com

Пример использования в Python:

import configparser

config = configparser.ConfigParser()
config.read('config.ini')

database_host = config['Database']['host']
database_port = config['Database']['port']
api_key = config['API']['key']

JSON-файлы (например, config.json):

JSON-файлы легко читаются как людьми, так и машинами. Пример config.json:

{
    "Database": {
        "host": "localhost",
        "port": 5432,
        "username": "user",
        "password": "password123"
    },
    "API": {
        "key": "your_api_key",
        "url": "https://api.example.com"
    }
}

Пример использования в Python:

import json

with open('config.json') as f:
    config = json.load(f)

database_host = config['Database']['host']
database_port = config['Database']['port']
api_key = config['API']['key']

Python-модуль (например, settings.py):

Вы также можете использовать обычные Python-модули для хранения конфигурации. Пример settings.py:

DATABASE = {
    'host': 'localhost',
    'port': 5432,
    'username': 'user',
    'password': 'password123'
}

API = {
    'key': 'your_api_key',
    'url': 'https://api.example.com'
}

Пример использования в Python:

from settings import DATABASE, API

database_host = DATABASE['host']
database_port = DATABASE['port']
api_key = API['key']

4. Переменные окружения:

Вместо использования файлов конфигурации, некоторые разработчики предпочитают хранить конфигурацию в переменных окружения. Это обеспечивает дополнительный уровень безопасности и удобства, особенно при работе с секретными данными.

Пример использования переменных окружения:

import os

database_host = os.environ.get('DATABASE_HOST', 'localhost')
database_port = os.environ.get('DATABASE_PORT', 5432)
api_key = os.environ.get('API_KEY', 'your_api_key')

Важные рекомендации:

Игнорируйте конфигурационные файлы в системе контроля версий (например, в файле .gitignore). Это позволит избежать случайного попадания конфиденциальной информации в репозиторий.
Не храните секретные данные в открытом виде. Используйте переменные окружения или шифруйте конфигурационные файлы при необходимости.
Документируйте конфигурацию. Оставьте комментарии или документацию в файлах конфигурации, чтобы другие разработчики понимали, какие параметры они могут настраивать.

Пример организации проекта.

Дан проект. Задача: управление контентом. Парсинг (Beautiful Soap, Selenium), обработка и публикация контента на сайте WordPress (через RestAPI) и в соцсетях (Телеграм, ВКонтакте, Youtube, Дзен, Рутьюб). Хранилище организовано в PostgreSQL и SQLAlchemy

Структура проекта

content_management_project/
|-- config/
|   |-- settings.py
|   |-- logging_config.py
|-- content_parser/
|   |-- __init__.py
|   |-- parser.py
|   |-- processors/
|       |-- __init__.py
|       |-- wordpress_processor.py
|       |-- social_media_processors/
|           |-- __init__.py
|           |-- telegram_processor.py
|           |-- vk_processor.py
|           |-- youtube_processor.py
|           |-- zen_processor.py
|           |-- rutube_processor.py
|-- database/
|   |-- __init__.py
|   |-- models.py
|   |-- db_utils.py
|-- main.py

Объяснение структуры:

config/: В этой папке вы можете хранить файлы конфигурации, такие как settings.py для общих настроек проекта и logging_config.py для настройки системы логирования.
content_parser/: Этот модуль отвечает за парсинг контента и его обработку. Внутри вы можете иметь различные подмодули и процессоры для обработки контента для различных платформ.
- parser.py: Основной модуль парсинга, который может использовать BeautifulSoup, Selenium и другие инструменты для извлечения данных.
- processors/: Подмодуль с различными процессорами для обработки контента.
  - wordpress_processor.py: Процессор для публикации контента на WordPress с использованием REST API.
  - social_media_processors/: Подмодуль для процессоров социальных медиа.
    - telegram_processor.py, vk_processor.py, youtube_processor.py, zen_processor.py, rutube_processor.py: Процессоры для соответствующих платформ.
database/: Этот модуль отвечает за работу с базой данных. Вы можете определить модели данных в models.py и использовать db_utils.py для утилит работы с базой данных.
main.py: Главный файл вашего приложения, который инициирует работу всего проекта.