Недостатки глобальных переменных:

1. Неконтролируемый доступ. Так как они не передаются явным образом, к ним можно легко получить доступ с помощью из слоев абстракции, которые о них не должны вообще знать.
Пример такой ошибки: обращение в БД из html-шаблонов

2. Усложнение использования кода из-за неявных связей. Невозможно глядя на функцию понять, что ей нужно для работы.
Например, если мы вызываем функцию foo, а она вызывает функцию bar, а та вызывает функцию baz, которая обращается к глобальной переменной XXX, мы не можем догадаться что XXX надо иницилизировать для использования foo.
Это можно документировать, но наличие такой документации невозможно проверять автоматически.

3. Неконтролируемый жизненный цикл. Глобальная переменная существует в глобальном скоупе и соответственно к ней есть доступ ещё на этапе импорта.
Соответственно если мы хотим инициализировать её чем-то кроме константы, мы должны контролировать порядок импортов или делать инициализацию так же на этапе импорта.
Так же она должна существовать без переприсвоения всё время жизни программы.

4. Сильное сцепление. Так как переменная инициализируется там же откуда её импортируют, в результате косвенно весь код использующий переменную сцеплен с кодом её иницилизации.
В результате код использующий такую переменную невозможно использовать не втаскивая конкретный код инициализации.

5. Невозможность иметь два экземпляра без изменения кода, использующего их.
Пример, раньше использовалось одно соединение с БД, но при повышении нагрузки часть запросов решили делать в read-only реплику.
В случае DI изменения так же потребуются, но есть возможность выбрать, где будет приниматься решение об использовании конкретного соединения, и не менять контракт использующих его частей.

6. Все выше сказанное усложняет тестирование кода.

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

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

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

На самом деле это не так:
* Приложение состоит из нескольких независимых частей, которые могут быть переиспользованы
* Некоторые части будут существовать в одном экземпляре, некоторые - нет (по крайней мере в будущем).
* Иногда настройки будут загружаться при старте приложения, иногда - перед созданием конкретных экземпляров классов. Например, при тестировании.

Дополнительно хочу обратить внимание, что зачастую исходный код распространяется в некотором упакованном виде или устанавливается директорию недоступную для изменения и его всё ещё надо настраивать.
Если наше приложение работает в окружении типа k8s, то прокинуть для него файлы может быть затруднительно.

Одновременно вспоминая принципы SOLID можно записать следующие принципы работы с настройками:

1. Настройки приложению должны передаваться как внешние данные: переменные окружения (и иногда файлы).
2. Конкретные "модули" приложения должны зависеть только от своих настроек и не знать о существовании других настроек
3. Настройки "модулей" приложения должны инжектироваться извне, а не читаться неявным образом (путем вызыва функции парсинга настроек или обращения к глобальной переменной)
4. Настройки приложения/"модулей" должны читаться при старте основного кода, а не при импорте
5. Модули не должны знать о том, как именно будут читаться настройки, но могут предоставлять хелперы для этого

Какие есть типичные АНТИПАТТЕРНЫ работы с настройками:

1. Файл settings.py, содержащий все "константы" настроек, редактируется при деплое. Все куски кода его импортируют.
2. Файл settings.py, содержащий глобальные переменные, заполненные сразу из переменных окружения.
3. Глобальная переменная, содержащая настройки, все её импортируют. То же самое что п.1, но в какбы-ООП стиле
4. Функция load_config(), которую все дергают. Для "оптимизации" может быть задекорирована @lru_cache. По сути то же самое что в п.3, но конфиг читается при первом обращении, которое зачастую происходит в глобальном скоупе и мы это не контролируем.
5. Один класс Settings и все классы ожидают его целиком, даже если используют лишь часть.

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

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

Несмотря на то, что питон позволяет использовать вложенные функции и классы, стоит их использовать с осторожностью.

По вложенными функциями я имею в виду следующий код:

def foo():
    def bar(): ...

Недостатки вложенных функций:
* Они создаются при каждом запуске внешней функции
* Их невозможно протестировать
* Они захватывают окружающие переменные, что приводит к появлению неявного изменяемого контекста, который недоступен для инспекции
* Увеличивают вложенность кода, что усложняет чтение
* Их невозможно переиспользовать

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

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


Под вложенными классами я имею в виду:

class A:
    class B: ...

Если исключить ситуацию, когда вложенные классы требуются фреймворком, то обычно их заводят по двум причинам:
* Чтобы просто объединить несколько связанных сущностей в одном неймспейсе. В этом случае мы просто получаем лишнюю вложенность кода и невозможность их импортировать независимо.
Вместо этого, в питоне в качестве неймспейсов принято использовать модули.

* Чтобы указать какие-то настройки связанные с поведением окружающего класса. Это создает вопросы, какие опции доступны. Так же такой класс не будет иметь экземпляров, что странно.
Вместо этого лучше воспользоваться полем класса с экземпляром какого-то класса. В определенных случаях можно передать эти параметры в декоратор или метакласс. Так же стоит рассмотреть вариант переноса этих настроек из класса в использующий его слой.

Про объекты и словари.

TLDR:
объект — это фиксированная структура данных с конечным набором полей.
словарь — это маппинг ключей в значения, не более.

Если не углубляться в детали реализации, то в питоне есть два способа объединить набор строк со значениями в одной сущности.
* Можно положить значения как атрибуты какого-то объекта. Для этого есть оператор точка или функции setattr/getattr
* Или можно сделать словарь. В этом случае идет обращение с помощью квадратных скобок или метода .get

Возможности обоих способов достаточно близки, но есть концептуальные различия.
1. объекты всегда создаются с помощью какого-то класса. В этом случае класс в том или ином виде содержит описание доступных полей.
2. для работы с атрибутами удобно использовать точку. И она не позволяет подставлять их динамически. Они должны быть известны на момент написания кода.
3. словарь одновременно содержит как ключи, так и свои атрибуты (например методы).
4. основной способ определения аннотации типа для словаря - указание типа ключа и типа значения. Какие же именно ключи там будут фигурировать обычно не определяется.
5. IDE и анализаторы кода учитывают вышесказанное и предлагают подсказки для обеспечения корректности кода. Например, если вы опечатаетесь в названии атрибута - IDE вам подскажет, а если неправильно введете ключ словаря - маловероятно.

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

* Если у нас есть фиксированные ключи, особенно имеющие разный физический смысл стоит создавать класс.
* Если у нас ключи могут динамически меняться, их состав не фиксирован на этапе разработки и они не отличаются друг от друга с точки зрения их смысла - стоит взять словарь

То есть это плохой вариант (не делайте так):

def greet_user(user):
    print("Hello,", user["nane"])

greet_user({
    "id": 1,
    "name": "ivan"
})

Этот код лучше оформить так:

@dataclass
class User:
    id: int
    name: str

def greet_user(user: User):
    print("Hello,", user.name)

greet_user(User(
    id=1, 
    name="ivan",
))

Есть ещё одно применение словаря - интеграция с внешними системами.

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

Продолжая тему адаптеров, при реализации их может понадобиться код конвертации класса "в словарь".
Естественным желанием тут будет добавление метода типа to_dict, однако следует подходить к этому подходу с осторожностью.

Дело в том, что один и тот же объект в дальнейшем может передаваться в разные сторонние API (сохранять в БД, возвращаться через REST API нескольких версий и т.п.). И каждый адаптер может иметь свои правила преобразования объекта. Например, если мы поддерживаем несколько версий Web API, они могут отличаться даже именованием одних и тех же полей. В других случаях могут отличаться правила преобразования некоторых типов как datetime.

Поэтому более правильным будет держать функции сериализации в том слое кода, который непосредственно отвечает за конечное представление.

Про приватные и публичные атрибуты

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

1. Разделение публичного API класса/библиотеки и деталей реализации.
На уровне договоренности принято называть атрибуты, предназначенные "для внутреннего использования" начиная с одинарной черточкой _.
Такое обозначение является лишь соглашением и не подкрепляется никаким механизмом в языке. Но при этом линтеры как правило проверяют доступ к таким атрибутам.

Термин "protected-атрибуты" тут может быть применен с большой натяжкой и не в том же смысле как в Java или C++
С другой стороны, в той же Java есть способы нарушить защиту предоставляемую модификаторами доступа.

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

2. Защита от переопределения атрибута наследниками.
Иногда мы хотим, чтобы методы класса обращались именно к его атрибуту, а если наследник определит свой, это никак не затрагивало нашу логику.
Это корректная ситуация, хотя и не очень частая. Для этого в питоне поддерживается механизм "name mangling", который включается использованием двойного подчеркивания в имени атрибута (__).
Конечно, к такому атрибуту все ещё возможно орбатиться и переопределить его, но это требует явных намерений от разработчика.
Это снова отличается от механики работы "private" атрибутов в других языках, хотя и пересекается с ними по одному из сценариев применения


Таким образом:
* если вы хотите указать разработчику, что атрибут (класс, функция, глобальная переменная) не являются частью API класса/модуля - испольузйте одну черточку
* если вы действительно хотите защититься от переопределения атрибуты наследниками класса - используйте две черточки
* в остальных случаях - работайте над архитектурой проекта

Подробнее:
* https://docs.python.org/3/tutorial/classes.html#private-variables
* https://martinfowler.com/bliki/AccessModifier.html

Про форматирование и инъекции.

В Python есть минимум 3 разных способа форматирования строк:
* f-строки
* .format
* %

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

Компьютер ожидает, что обрабатываемый текст будет оформлен согласно определенным правилам и вы не можете просто так вставить туда произвольную строку не нарушив при этом структуру текста.
Речь идет о формировании SQL, XML, HTML, JSON, консольной команды, URL, регулярных выражений и ещё кучи различных типов строк.

Как правило такая проблема решается одним из двух способов:
1. Ручное экранирование данных
2. Вызов специальных библиотечных методов, подставляющих данные безопасно.

Как правило лучше выбирать второй способ, так он проще и оставляет меньше шансов ошибиться.

Рассмотрим примеры.

1. SQL
Допустим вы хотите прочитать данные из БД и пишете такой запрос:
cur.execute(f"SELECT * FROM users WHERE login = '{somelogin}'")
Он будет работать в каких-то случаях и обязательно сломается, если переменная somelogin будет содержать, например, кавычку.
В некоторых случаях это может привести к исполнению произвольного SQL кода.

Замена f-строки на .format или форматирование через % ничего не изменит.
Правильно тут было бы сделать так (использовать тут ? или другой символ зависит от вашей СУБД):
cur.execute("SELECT * FROM users WHERE login = ?", (somelogin,))

2. HTTP
Если вы делаете GET запрос, вы можете написать такой код:
requests.get(f"http://site.com?search={query}")
Он будет работать некорректно если переменная query, например, содержит знаки &?
Правильно написать так:
requests.get("http://site.com", params={"search": query})

3. Shell
Следующий код сломается, если имя папки содержит пробел или точку с запятой, и может привести к исполнению произвольных команд.
subprocess.run(f"ls {dirname}", shell=True)
Его стоит заменить на
subprocess.run(["ls", dirname])

4. HTML
В случае подстановки данных в HTML стоит воспользоваться специальными шаблонизаторами. Например, jinja.


Доп материалы:
* https://xkcd.ru/327/
* https://ru.wikipedia.org/wiki/Внедрение_SQL-кода
* https://ru.wikipedia.org/wiki/Межсайтовый_скриптинг

Оглавление

Архитектура, паттерны, подходы
• Недостатки глобальных переменных
• Ошибки при обработке настроек
• Dependency Injection
• FastAPI и Dependency Injection
• Обработка исключений
• Аутентификация и авторизация
• Аутентификация и IdentityProvider
• Пулы объектов и соединений
• Абстрактные классы и интерфейсы
• Вложенные классы и функции
• Форматирование и инъекции
• Логирование
• Цели написания частей кода
• Двухфазная инициализация
• Моки, стабы и патчи
• Полиморфизм при наследовании и LSP
• Data Transfer Object (DTO)
• Dependency Inversion Principle
• Anti Corruption Layer

Базы данных
• Первичные ключи в БД
• Базы данных и компоненты
• БД и Миграции
• Тонкости использования alembic
• Стратегии загрузки связанных данных из РСУБД
• SQL, соединения и слои абстракции
• Unit of Work
• Generic-репозиторий - просто ленивый антипаттерн
• Паттерны работы с базами данных
• Стейт при работе с базами данных

Python
• Объекты и словари
• Приватные и публичные атрибуты
• Конструктор и __init__
• Ссылки и is
• Управление памятью в Python
• Работа import и структура проекта
• Механика импорта и побочные эффекты
• Концепции, связанные с декораторами в Python
• Декоратор как паттерн и как сахар в Python
• Виртуальные окружения Python
• Asyncio и цикл событий
• Asyncio и колбэки

ОС, устройство компьютера и сети
• Текущий каталог и пути
• Переменные окружения и dotenv
• Терминал, консоль и командная оболочка
• Запуск программ в фоне на Linux
• Запуск программ и команд
• Потокобезопасность и конкурентный доступ
• Виды многозадачности
• Способы параллелизации задач
• Сетевые протоколы
• Веб приложение и масштабирование
• Компоненты web-приложения
• Pull, poll, pool и spool
• float и Decimal
• Словари

Авторское
• Микрооптимизации кода и AST
• Dishka - IoC-контейнер для Python
• Создание ботов с интерактивным меню

FastAPI и Dependency Injection.

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

Что такое Dependency Injection?
Это достаточно простая концепция, которая говорит: если объекту что-то нужно, он не должен знать, как оно создается.

Пример:
Ваш класс User хочет уметь ходить в Shop.
Он мог бы создать магазин сам, но тогда мы не сможем всем пользователям дать один магазин. И вообще придется переносить в него всю логику строительства магазинов со всеми вариантами её применения.
Вместо этого предлагается чтобы User получал экземпляр Shop в __init__.
И уже наш код, создающий пользователей, сможет передать туда нужный магазин. При чем если у нас пользователи бывают в разных местах системы мы сможем в каждом случае иметь правильные магазины и свою логику работы с ними.

Таким образом весь механизм DI состоит из двух частей:
1. Есть класс/функция, которая от чего-то зависит
2. Есть логика, которая подставляет эту зависимость

Замечание:
DI - хорошая вещь, но не увлекайтесь слишком сильным дроблением кода. Не стоит применять эту концепцию для частей, являющихся деталью реализации самого класса.


В случае FastAPI, у нас есть механизм автоматической подстановки зависимостей в наши view-функции (это обычно называется IoC-контейнер).
Он состоит аналогично из двух частей
* С помощью Depends мы обозначаем зависимость. Если зависимость идентифицируется по аннотации типа параметра функции, то Depends используется без параметров.
* С помощью app.dependency_overrides мы определяем фабрику, возвращающую эту зависимость или генераторную функцию

В простом случае это может выглядеть вот так:

# определяем view
@router.get
def my_view_funcion(param: Session = Depends()): 
    ...

# в мейне создаем приложение и настраиваем
app = FastApi()
app.dependency_overrides[Session] = some_session_factory

Типичной ошибкой, которую допускает даже автор fastapi является указать настоящую функцию создания зависимостей в Depends


# так делать не стоит
def my_view_funcion(param: Session = Depends(create_session)): ...

В этом случае вы конечно все ещё можете переопределить зависимость в тестах, но ваш код оказывается сцеплен с кодом создания объекта Session и более того, вы не можете настроить логику работы функции create_session при создании приложения.
То есть это не DI, а только его половинка.


Функционально Depends в fastapi можно использовать не только для DI, но и для переиспользования части логики или даже параметров запроса и это накладывает свой отпечаток.
Дело в том, что FastAPI генерирует open api (swagger) спецификацию для view-функции не только на основе её параметров, но так же на основе параметров её зависимостей.

Поэтому, если наша зависимость (класс Session) имеет конструктор с параметрами, мы увидим их в swagger-спецификации и для отключения этого нет встроенных средств.
Избежать это можно двумя способами:

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

Первый способ в коде выглядит так

class MyProto(abc.ABC):
    ...

@router.get
def my_view_funcion(param: MyProto = Depends()): 
    ...

app = FastApi()
app.dependency_overrides[MyProto] = some_session_factory

Второй способ - так:

def get_session_stub():
    raise NotImplementedError  # это реально тело этой функции
    
@router.get
def my_view_funcion(param: Session = Depends(get_session_stub)): 
    ...

app = FastApi()
app.dependency_overrides[get_session_stub] = some_session_factory

Второй способ можно несколько уницифировать, например, так:
https://gist.github.com/Tishka17/9b2625753c80681e8ba688c84d834bb6

Доп материалы:
* https://ru.wikipedia.org/wiki/Внедрение_зависимости
* https://martinfowler.com/articles/injection.html
* https://fastapi.tiangolo.com/tutorial/dependencies/
* https://github.com/adriangb/di

SQL, соединения и слои абстракции

При написании приложения, работающего с БД без использования ORM возникают вопросы о его структурировании и жизненном цикле объектов БД.

Если не рассматривать другие сущности, то условно такое приложение можно поделить на следующие слои (да простит меня Дядюшка Боб):

* Адаптеры для базы данных
* Бизнес-логика
* Контроллеры и представления
* Интеграционный слой


Рассмотрим чуть подробнее:

Адаптеры для базы данных
Это классы или функции, скрывающие в себе детали построения запросов в базу данных. Именно тут пишется SQL код, происходит разбор данных, полученных из курсора в понятные остальному коду классы.

Зачастую удобно сделать класс, который будет содержать текущее соединение с БД в своем поле и методы, делающие внутри один или несколько SQL-запросов, имеющих смысл с точки зрения основной логики программы. Этот код НЕ должен сам создавать соединение, воспользуйтесь Dependency Injection. Он так же не должен управлять транзакциями. Благодаря этому можно в дальнейшем комбинировать вызовы его методов. Также стоит избегать использования в интерфейсе этого класса слишком абстрактных методов, чтобы не переносить детали работы с БД в слой бизнес-логики.

Бизнес-логика
Этот слой содержит код обработки конкретных сценариев использования программы (use cases), то есть основную логику программы. Она абстрагирована от деталей работы базы данных или представления данных для пользователя. Для работы с базой данных она обращается к соответствующим адаптерам. Именно бизнес-логика знает о том, какие операции с базой данных являются неделимыми и управляет транзакциями.

Бизнес-логика не знает о том, откуда взялся адаптер БД, а просто использует его.

Контроллеры и представления
По сути это адаптеры, связывающие ваше приложение с его пользователями. Это могут быть view-функции веб-фреймворка, хэндлеры в телеграм боте, задачи celery, cron джобы и т.п.

Они реагируют на возникающие в вашем фреймворке события и вызывают бизнес-логику для его обработки. Контроллеры обрабатывают входящие данные, трансформируют их в понятные бизнес-логике структуры, а представления делают обратные преобразования.

Так как обрабатываемые события имеют понятный жизненный цикл, а также потому что мы технически не можем конкурентно использовать одно соединение БД, именно тут мы можем создавать наши соединения. Однако, так как настройка соединения выходит за рамки задачи контроллера, он должен создавать его не сам, а с помощью какой-то фабрики, получаемой из интеграционного слоя.

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

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

Итого:
1. Адаптер БД реализует единичные действия с базой и скрывает SQL код
2. Бизнес-логика оперирует транзакциями и вызывает методы адаптеров
3. Контроллер вызывает один или несколько use case в рамках соединения которое он получил сам или из мидлвари.

В начале обработки чего-либо (веб-запроса, сообщения в телеге и т.п.) достаем соединение, в конце обработки - возвращаем туда, откуда достали.
Также стоит отметить, что соединение с БД не обязательно физически открывать каждый раз, стоит использовать пулы соединений для ускорения.

Дополнительные материалы:
* https://ru.wikipedia.org/wiki/Адаптер_(шаблон_проектирования)
* https://martinfowler.com/eaaCatalog/repository.html
* https://www.ozon.ru/product/144499396/

Запуск программ в фоне на Linux

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

1. Разовый запуск команд, которые долго работают;
2. Запуск сервиса, который должен постоянно или периодически работать.

Если в первом случае речь идет о запуске команды из консоли, то, возможно, мы захотим увидеть её вывод или продолжить работать в этой консоли через какое-то время. Если мы работаем в консоли нашего компьютера, ничего дополнительно делать не требуется. Однако если мы подключаемся к серверу по SSH, то при разрыве соединения приложение через какое-то время будет закрыто. Для таких случаев актуально использовать такие программы как screen или tmux, которые позволяют запустить сессию консоли, не привязанную к конкретному терминалу. Кроме того они умеют эмулировать несколько консолей в рамках одной. При этом вы сначала запускаете screen, в котором уже вводите нужные команды. Если потом вы отключитесь от терминала, вы сможете вывести список открытых сессий screen и подключиться к ним для продолжения работы.

Альтернативным вариантом для запуска долгой команды, без необходимости продолжить взаимодействие со скриптом может стать systemd-run.

В случае запуска постоянно работающего сервиса частыми требованиями будут:
* автоматический старт после перезагрузке сервера;
* перезапуск в случае аварийного завершения;
* просмотр статуса;
* ручная остановка и перезапуск;
* сбор логов;
* ограничение прав, настройка последовательности запуска и т.п.


В современных серверных дистрибутивах Linux для этого используется systemd. Это предустановленное приложение, которое занимается обслуживанием всех системных фоновых сервисов и связанных с этим задач. Так же вместе с ним идет journald, который с этих сервисов собирает логи. Добавление своего сервиса сводится к созданию service-файла и использованию команд типа systemctl или journalctl.

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

В случае запуска периодических задач раньше использовался cron, однако сейчас его задачи также выполняется systemd (systemd-timers). В отличие от предшественника он имеет более богатые возможности настройки и возможность сбора логов. Настройка делается практически так же, как для запуска постоянно работающих сервисов. Более того, в современных системах cron на самом деле эмулируется тем же systemd.

Отдельно стоит также отметить возможности контейнеризации приложений. В частности, docker или podman. Они позволяют изолировать окружение, в котором работает приложение (отделить файловую систему, доступ к процесса, сеть и т.д.). Использование контейнеров также упрощает процесс дистрибуции приложения. Так же для создания масштабируемых систем с помощью Kubernetes используются технологии контейнеризации.

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


Дополнительные материалы:
* https://habr.com/ru/post/503816/
* https://github.com/tmux/tmux/wiki/Getting-Started
* https://systemd.io/
* https://github.com/tmux/
* https://www.gnu.org/software/screen/manual/
* https://docs.docker.com/

Потокобезопасность и конкурентный доступ

Большинство приложений, которые мы пишем, используют конкурентность.
Это могут быть многопоточные веб-приложения, телеграм-боты с asyncio, GUI приложения с фоновой обработкой и т.п.

При разработке таких приложений стоит задумываться, к каким объектам вы имеете доступ только из одного логического потока, а какие из них используются конкурентно. Если вы работаете с одним объектом из нескольких потоков/asyncio тасков возможна ситуация, называющаяся "состоянием гонки" (race condition). Это состояние, когда результат работы кода зависит от того в какой последовательности выполняются действия внутри конкурентных операций.

Приведу пример:

counter = 0

def do():
    global counter
    if counter < 1:
        sleep(0.01)
        counter += 1

Если вы запустите такой код последовательно несколько раз, значение counter будет равно 1. Однако, если вы запустите его в несколько потоков, то возможны произвольные значения. Замена threading на asyncio проблему в данном случае не решит.

Когда мы работаем с многопоточным кодом переключение может произойти практически в любом месте кода. При использовании же asyncio, переключения происходят в конкретных точках (await), что несколько уменьшает вероятность появления гонок, но не исключает их полностью.

Можно придумать достаточное количество других примеров состояния гонки, которые могут достаточно разнообразные последствия для работы программы: от нарушения логики работы кода непредсказуемым образом, до утечек памяти или падений с segmentation fault. Есть разные методы борьбы с таким состоянием: можно использовать блокировки, _compare-and-swap_ алгоритмы, но самое надежное - отказаться от использования общих данных совсем.


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

Примеры:
requests.Session - потокобезопасный объект. Вы можете посылать запросы из нескольких потоков используя одну сессию. Однако тут возможны логические ошибки, если сервер пришлет разные куки в ответ на конкурентные запросы.

asyncio.Queue - не потокобезопасен, однако безопасен для использования в конкурентных тасках asyncio.

sqlite3.Connection - не потокобезопасен. По умолчанию, sqlite дополнительно выдает ошибку, если вы попытаетесь использовать соединение не из того потока, где вы его создали. Отключение этой проверки не сделает соединение безопасным для использования из нескольких потоков, это просто дополнительная защита.
Как дополнительный фактор против конкурентного использования стоит отметить транзакции субд. Ведь если вы используете одно соединение, вы работаете в одной транзакции. И когда один из потоков решит её зафиксировать (commit), а второй - откатить (rollback) результат будет неизвестен.

Session из SQLAlchemy - не потокобезопасна по тем же причинам, как и соединения с СУБД. А вот Engine, который используется для создания сессий, уже потокобезопасен.

Объекты интерфейса tkinter, Qt, Android SDK и других GUI фреймворков также не рассчитаны на использование из нескольких потоков. В этом случае у вас, как правило, есть один поток для работы с GUI и только из него вы можете обновлять элементы интерфейса. Также эти фреймворки предоставляют инструменты для передачи в этот поток информации о необходимости обновить интерфейс (например, механизм signal-slot).

Доп ссылки:
* https://ru.wikipedia.org/wiki/Состояние_гонки
* https://ru.wikipedia.org/wiki/GIL
* https://docs.sqlalchemy.org/en/14/orm/session_basics.html#is-the-session-thread-safe

Пулы объектов и соединений.

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

Для решения проблемы долгой инициализации объекты придуман паттерн "пул объектов". В этом случае у вас есть заготовленный набор инициализированных объектов. Каждый раз, когда вам нужен такой объект, вы не создаете его сами, а запрашиваете из пула. Соответственно, возвращаете туда после использования. Пул может создавать эти объекты сразу при старте или быть ленивым - создавать по запросу и запоминать те, что уже были им созданы. В зависимости от ситуации пул может также иметь свою логику по управлению жизненным циклом таких объектов - будь то сброс состояния, ограничение времени жизни или размера пула.

Стандартная практика - один раз (при старте приложения) создать пул, в дальнейшем использовать его в разных частях кода. При этом вы можете иметь несколько пулов, если того требует логика. Но просто так регулярно пересоздавать пул бессмысленно.

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


Примеры:

* requests.Session - кроме дополнительной логики по управлению куками содержит внутри пул соединений с серверами, по которыми в дальнейшем посылаются HTTP(s) запросы. Использовать requests без Session скорее всего будет плохой идеей

* aiohttp.ClientSession - аналогичный объект для асинхронного "аналога" - библиотеки aiohttp. Несмотря на то, что в примерах из документации зачастую сессия создается по месту запроса, рекомендуется инициализировать её один раз и в дальнейшем переиспользовать

* psycopg2.pool - модуль с несколькими вариантами пулов соединений с СУБД Postgresql.

* Engine из SQLAlchemy также использует пул соединений. При этом возможна настройка таких параметров как время жизни соединения, дополнительные проверки его доступности, размер пула. В том числе возможно и использование NullPool, который по факту не является пулом, но совместим с ним по интерфейсу.

Дополнительные материалы:

* https://habr.com/ru/company/otus/blog/443312/
* https://habr.com/ru/post/443378/
* https://docs.sqlalchemy.org/en/14/core/pooling.html
* https://docs.aiohttp.org/en/stable/client_reference.html
* https://docs.python-requests.org/en/latest/user/advanced/#session-objects

БД и миграции

При работе с базами данных нам необходимо, чтобы структура данных в БД соответствовала коду:
Во-первых, мы должны изначально создать необходимые таблицы или коллекции с правильными индексами и т.п.
Во-вторых, при изменении кода приложения мы должны актуализировать эту структуру, создать новые таблицы, переложить данные по другому и т.п. Даже если сама СУБД не подразумевает фиксированной схемы лежащих в ней данных, вы можете захотеть уменьшить разнообразие вариантов хранения.

Кроме этого у нас есть дополнительные ограничения:
* Код не должен иметь права отключать проверки в СУБД, менять и создавать индексы и настраивать связи;
* Запуск нескольких копий кода одновременно (актуально для веб-приложений) не должен приводить БД в неработающее состояние;
* Приложение может быть развернуто на нескольких окружениях, которые обновляются независимо;
* Иногда должна быть возможность вернуть базу данных в предыдущее состояние из-за ошибок;
* Иногда мы хотим, чтобы несколько версий кода работали одновременно. Например, при green-blue/canary deployment.

Таким образом я бы выделил следующие подходы:
1. Состав и структура таблиц должны определяться на момент проектирования/реализации версии кода. Таблицы не должны генерироваться динамически во время работы приложения;
2. Для приведения структуры БД в нужное состояние пишутся скрипты миграции;
3. Скрипты миграции вызываются при деплое приложения. Приложение не должно самостоятельно вызывать скрипты миграции при старте или в другой момент во время работы;
4. Каждый скрипт миграции должен содержать все необходимые данные для его работы. Скрипт миграции не должен обращаться к основному коду приложения, так как код будет меняться, а миграция должна оставаться работоспособной;
5. Скрипт миграции не должен редактироваться после выпуска очередной версии приложения. Если вы забыли мигрировать часть данных, придется делать ещё одну миграцию;
6. Миграции необходимо проверять/тестировать. Тестовые базы данных должны обновляться только с помощью миграций;
7. Инструменты для автоматической генерации миграций могут помочь в работе, но вы должны проверять и редактировать сгенерированный код.

Если есть требование обновления без простоя, то миграции должны сохранять структуру БД совместимой для нескольких версий приложения. Иногда это потребует разбивать миграцию на несколько частей. Например, если вам необходимо переименовать колонку БД, в одной миграции вы добавите новую колонку, а старую сделаете вычислимой. Затем, только после полной выкатки новой версии кода в прод, можно будет применить вторую миграцию, удаляющую старую колонку.

Если же вы делаете эти вещи, вероятно вы используете БД неправильно:
1. Создаете таблицы во время работы программы;
2. Вызываете meta.create_all() (или аналог для вашей ORM) для создания структур БД для ваших моделей;
3. Вызываете миграции автоматически при старте приложения;
4. Импортируете в миграциях модели или другой код из основной части проекта;
5. Меняете код миграций после того как они могли быть использованы;
6. Не запускаете миграции нигде кроме прода;
7. Не читаете код автоматически сгенерированных миграций.

Дополнительно хочу отметить, что миграции - это не обязательно простые изменения структуры, такие как добавление или удаление колонки/таблицы. Иногда вам потребуется произвести какую-то длительную работу по модификации данных (например, посчитать значение колонки для БД из миллиарда записей).

И хотя обычно эти советы дают для реляционных СУБД, так как те требуют соблюдения структуры таблиц, они также применимы и для документо-ориентированных баз данных. Вы можете обойтись без миграции для добавления nullable поля в MongoDB, но скорее всего вам потребуется её делать в том или ином виде, если вы захотите разбить колонку на две или вместо одного числа начать хранить список.

Дополнительные материалы:
* https://habr.com/ru/company/yandex/blog/511892/
* https://habr.com/ru/company/flant/blog/471620/
* https://alembic.sqlalchemy.org/en/latest/

Обработка исключений

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

Говоря о каждой конкретной строке кода можно выделить два вида исключений:
* ожидаемые (возможные) - исключения, которые мы предполагаем, что могут возникнуть в данном месте, и знаем какие действия принимать в этой ситуации
* неожиданные - исключения, которые не должны были возникнуть в этом месте, но возникли из-за неверно написанного кода и мы не имеем стратегии поведения в этой ситуации


Отсюда следуют следующие советы:
1. Всегда указывайте исключение, которое вы ловите. Если вы не знаете, что за исключение может возникнуть - вы не знаете корректно ли обрабатывать его вашим способом.
2. Указывайте максимально конкретный класс исключения.
3. Оборачивайте в try/except наименьший возможный код. Если требуется - разбивайте его на несколько выражений
4. Обрабатывайте исключения именно там, где у вас достаточно информации для принятия решения, что делать в данной ситуации.


Частой ошибкой новичков бывает написать просто except: или except Exception - не делайте так.
* Обработка всех подряд исключений, как правило, вообще не корректна, так как туда входит, например, KeyboardInterrupt, по которому ожидается как раз завершение программы. Но это допустимо, если после такой обработки вы пробросите исключение дальше.
* Обработка же Exception актуальна на уровне фреймворка, когда у нас есть стандартный способ реакции на неизвестные ошибки - выдача клиенту ответа с кодом 500, повтор обработки сообщения из очереди т.п.

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

Говоря о реализации адаптеров для различных сервисов или БД хорошей идеей будет ввести свои классы исключений

* Реализуя адаптер мы хотим скрыть детали реализации. Например, мы реализовали класс, реализующий хранение определенных сущностей в БД. Затем после очередного рефакторинга мы вынесли это в отдельный микросервис. Интерфейс адаптера при этом не изменился и мы ожидаем что использующий такой адаптер код не будет меняться. И если исключения вроде OSError или ValueError достаточно нейтральны и почти не говорят о реализации, то классы исключения, принадлежащие конкретной используемой библиотеки не стоит прокидывать извне такого адаптера.

* Вторая причина для введения своих классов исключений - изменение детализации. С одной стороны, разные сторонние исключения могут означать одну ошибку с точки зрения нашей логики (как например, разные виды сетевых ошибок могут означать просто недоступность внешнего сервиса). С другой - наоборот, возникновение исключения одного типа в разных местах кода адаптера может означать разное для вызывающего кода.

Дополнительные материалы:
* https://martinfowler.com/articles/replaceThrowWithNotification.html
* https://peps.python.org/pep-0008/#programming-recommendations

Про импорты и структуру проекта

Когда вы импортируете какой-то модуль в вашем коде, питон не учитывает, в каком файле этот импорт находится, влияет только то, как был запущен код.
Если модуль не был раньше загружен, питон пытается его найти по очереди в нескольких папках, которые можно посмотреть в переменной sys.path

По умолчанию она содержит примерно такие каталоги (в некоторых ситуациях, например, при использовании embedded версии python, состав может отличаться):
* каталог, добавляемый при запуске
* каталоги указанные в переменной окружения PYTHONPATH
* каталог текущего активированного виртуального окружения
* каталог установки python

1. Если вы запускаете ваш скрипт командой python scriptname.py, то первым в списке будет тот каталог, где находится запускаемый скрипт. Текущий каталог не имеет значения.
2. Если вы запускаете ваш код командой python -m packagename, то первым в списке будет текущий каталог. При запуске питон попытается найти и импортировать packagename по общим правилам.
3. Если вы запускаете код с помощью других инструментов вроде pytest, они тоже могут сами добавлять что-то в sys.path.

Скорее всего, вам не стоит самостоятельно менять sys.path, так как алгоритм его заполнения стандартный и привычен для всех. Если по каким-то причинам вас он не устраивает, возможно у вас неверная структура проекта.

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

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

1. Вынести запускаемые скрипты на верхний уровень, а остальной код упаковать в пакет.

Упаковка кода в пакет с уникальным именем позволяет исключить конфликты имен. А вынесение всех запускаемых файлов на один уровень делает состав sys.path предсказуемым.

Выглядеть это будет примерно так:

├── appname
│  ├── __init__.py
│  ├── other_module.py
│  └── some_module.py
├── cli_module.py
└── requirements.txt

2. Создать распространяемый пакет (рекомендую).

В этом случае вы упаковываете весь код в пакет, что помогает исключить конфликты имен.
Для запуска команд вы можете использовать синтаксис python -m appname.cli_module или заполнить секцию entry_points в файле с описанием проекта (setup.cfg, pyproject.toml), после чего иметь свои кастомные консольные команды. В обоих случаях вы сможете запускать код, находясь в любом каталоге, без необходимости указывать полные пути к файлам.

Для удобства разработки с таким подходом удобно устанавливать пакет в editable-режиме с помощью команды типа pip install -e .

Структура будет примерно такой:

├── pyproject.toml
└── src
    └── appname
        ├── __init__.py
        ├── cli_module.py
        ├── other_module.py
        └── some_module.py

Дополнительные материалы:
* https://packaging.python.org/en/latest/
* https://docs.python.org/3/reference/import.html
* https://docs.python.org/3/library/sys.html#sys.path
* https://ru.wikipedia.org/wiki/Рабочий_каталог

Механика импорта и побочные эффекты

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

Каждый раз, когда вы импортируете новый, ранее не импортированный, модуль, питон выполняет его код. Даже если вы делаете from .. import, это все равно требует однократного выполнения исходного кода модуля.
Питон хранит в памяти все импортированные модули, поэтому код будет выполнен один раз. Они доступны через sys.modules

Фактически строка import x означает:
1. Найди модуль x в кэше, если там его нет - выполни его код и сохрани модуль в кэш;
2. Создай в текущей области видимости переменную x и присвой ей загруженный модуль в качестве значения.

Соответственно, from x import y означает:
1. Найди модуль x в кэше, если там его нет - выполни его код и сохрани модуль в кэш;
2. Создай в текущей области видимости переменную y и присвой ей в качестве значения атрибут y из модуля x.

Ну и наконец, from x import y as z означает:
1. Найди модуль x в кэше, если там его нет - выполни его код и сохрани модуль в кэш;
2. Создай в текущей области видимости переменную z и присвой ей в качестве значения атрибут y из модуля x.

То, что при этом выполняется код, позволяет нам делать различную динамику при инициализации модуля: будь то загрузка данных, инициализация констант, создание различных реализаций кода в зависимости от окружения. Однако стоит быть осторожным и не писать в глобальной области видимости код, который влияет на что-то ещё кроме текущего модуля.

Импорты изначально предназначены для получения доступа к каким-то именам (константам, функциям, классам), поэтому ожидают что среди них не будет лишних и что порядок не важен. Исходя из этого можно ввести определенные правила форматирования импортов: PEP8 рекомендует нам группировать импорты по типам, многие линтеры также просят придерживаться алфавитного порядка и удалять неиспользуемые импорты. Никто не ожидает, что порядок импортов модулей может повлиять на работу кода (есть несколько исключений, но они общеизвестны и все равно сомнительны). Никто не ожидает, что удаление импорта модуля, который не используется ниже по коду, может повлиять на работу кода.

Если вы импортируете модуль ради выполнения какой-то логики в коде модуля, то это будет неожиданно для поддерживающего код и может сломаться при любом изменении в порядке импортов. Вместо этого стоит такой код поместить в функцию и вызывать её уже по месту, например в функции main.

Дополнительные материалы:
* https://peps.python.org/pep-0008/#imports
* https://www.flake8rules.com/rules/F401.html
* https://docs.python.org/3/reference/import.html

Переменные окружения и dotenv

Когда мы пишем какие-то сервисы (веб-приложения, боты, обработчики задач), им бывает необходимо передать какие-то настройки. Частыми вариантами будут: реквизиты для доступа к базе данных, токен для сторонних API и т.д.

В общем случае у нас есть два стандартных варианта передачи настроек:
* файлы конфигурации
* переменные окружения

Файлы конфигурации удобны, когда настроек много и они имеют сложную структуру. Но при запуске сервиса в некоторых окружениях, таких как AWS Lambda, Kubernetes и Heroku доставка таких файлов с настройками до работающего экземпляра приложения может быть нетривиальна.
В противовес этому, во многих случаях такие сервисы позволяют через свои способы настройки указать переменные окружения, с которыми будет запущен процесс. Да, мы не сможем передать в этом случае сложные иерархические структуры, но зачастую это не нужно.

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

Чтобы передать переменные окружения нашему приложению, мы можем:
* При использовании bash/sh/zsh сделать export этих переменных или указать их перед командой которую мы выполняем
* Так же для bash удобно подготовить один или несколько файлов с инструкциями export и применять их с помощью команды source
* При запуске через Pycharm переменные окружения можно задать в настройках конфигурации запуска. Иногда удобно иметь несколько таких конфигураций, чтобы отлаживать софт с разными настройками. Другие IDE имеют аналогичные возможности.
* Так же вы всегда можете задать переменные окружения глобально средствами вашей ОС. Но тогда для смены их возможно придется перезайти в учетную запись.
* При запуске сервиса через systemd вы можете указать переменные окружения прямо в service файле или указать из какого файла их необходимо прочитать
* При запуске через docker так же они указываются в команде запуска контейнера docker run напрямую или через --env-file. В случае`docker-compose` эти возможности сохраняются

Стоит отметить относительную популярность библиотек типа python-dotenv. Они позволяют во время работы приложения прочитать конфигурационный файл своего формата и поменять переменные окружения текущего процесса согласно этому файлу. Опасность этого подхода в том, что в момент загрузки этого файла приложение уже работает и при наличии других архитектурных проблем эти значения могут конфликтовать с уже инициализированными объектами, что потребует дополнительных усилий для поддержания работоспособности кода. Некоторые реализации библиотек для чтения .env-файлов могут искать файлы не только в текущем каталоге, но и вверх в каждом родительском каталоге, что может приводить к непредсказуемому поведению кода.

Хочу также обратить внимание, что хотя формат конфига python-dotenv похож на используемый docker, systemd или bash файл, эти все форматы не совместимы. Где-то вы можете ставить пробелы около знака =, где-то допустимо или требуется писать export, где-то невозможно задать многострочные значения и т.д.


Дополнительные материалы:
* https://12factor.net/
* https://www.freedesktop.org/software/systemd/man/systemd.exec.html
* https://docs.docker.com/compose/env-file/
* https://ru.wikipedia.org/wiki/Переменная_среды