В России введут комиссию за обмен USDT

Российский законопроект впервые чтения вводит регулирование криптовалют через пять категорий организаций и требует налогообложения прибыли криптообменников. Закон затронет популярные активы типа USDT и BNB, контролируемые недружественными странами. Основная цель — обязать обменники делиться доходами с бюджетом через комиссии и экономические стимулы, что в итоге увеличит затраты для рядовых пользователей и может стимулировать переход на альтернат…

➡️ Читайте на сайте: https://aff.top/blog/v-rossii-vvedut-komissiiu-za-obmen-usdt

🧠 Ещё больше инсайтов → в канале AFF.top

Python-скрипт можно сделать исполняемым без магии — и это снова проговорили в курсе Real Python

В курсе Structuring Your Python Script разбирают, куда складывать runnable-части, как группировать imports по стандарту, и как выносить constants при рефакторинге.
Отдельно показывают ясную точку входа через if __name__ == "__main__" и запуск скрипта на Unix-like системах через shebang.

Для тех, кто пишет утилиты, ETL-скрипты и маленькие сервисные CLI, это базовая гигиена репозитория.
Если скрипт живёт дольше одного спринта, порядок в imports и явный entry point экономят время на ревью и уменьшают число “а почему оно запускается само?”.

Скучно только до первого падения в проде.

f-строки снова всплыли: Real Python прогнал мини-язык формата по всем больным местам

Quiz на Real Python пересобирает форматирование в Python через f-strings и str.format().
Внутри — выравнивание и ширина, точность для чисел, типы представления, разделители тысяч, знаки, динамические specifiers и проценты.

Для тех, кто пишет скрипты и сервисы на Django/FastAPI, это не теория.
Такие вещи регулярно ломают отчёты, CSV-выгрузки, письма и админки, когда формат нужно держать одинаковым на разных данных.
Полезно прогнать это руками, если в коде есть суммы, проценты и табличный вывод.

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

Starlette ломают не роуты, а мелкие привычки вокруг ASGI

Starlette часто берут как «лёгкий фундамент» для FastAPI и своих микросервисов. И именно там всплывают типовые ошибки: смешивают слой HTTP и бизнес-логику, тащат тяжёлые зависимости в middleware, а потом удивляются, почему приложение стало вязким.

На что смотреть сразу:
— middleware оставляйте для кросс-сечных вещей: auth, trace id, headers, логирование;
— в endpoints не держите долгие sync-операции, иначе блокируется event loop;
— для фоновых задач не полагайтесь на «авось» — выносите их в отдельный воркер или очередь;
— WebSocket и обычный HTTP лучше проектировать как разные сценарии, а не один универсальный хендлер.

Ещё одна частая проблема — ошибки обработки исключений. В Starlette удобно ловить всё через handlers, но если складывать туда бизнес-исключения вперемешку с системными, быстро теряется прозрачность. Разделяйте: одно место для доменных ошибок, другое — для неожиданных падений и 500.

И главное: держите приложение маленьким по границам ответственности. Starlette хорош там, где маршрут тонкий, зависимости явные, а жизненный цикл запроса не превращён в комбайн. Тогда фреймворк остаётся быстрым, предсказуемым и не требует героизма при поддержке.

В App Store снова появилось приложение Telegram для Apple Watch

Telegram вернул приложение для Apple Watch в App Store с поддержкой сообщений, голосовых и текстовых сообщений, гифок и стикеров. После переиздания приложения в сторе можно ожидать запуска таргетированной рекламы в Telegram ADS, что открывает возможности для тестирования MVA-приложений на iOS через новый канал трафика.

➡️ Читайте на сайте: https://aff.top/blog/v-app-store-snova-poiavilos-prilozhenie-telegram-dlia-apple-watch

🧠 Ещё больше инсайтов → в канале AFF.top

7 ошибок в Django, которые незаметно ломают проект уже после первого релиза

— models.py разрастается до свалки: бизнес-логика, валидация и запросы живут в одной точке. Через месяц это сложно тестировать и почти невозможно переиспользовать.

— N+1-запросы маскируются под «всё работает». Один лишний цикл в шаблоне или сериализаторе — и страница начинает тормозить под реальной нагрузкой.

— forms и serializers используют как единственный слой проверки. В итоге одни и те же правила дублируются в view, model и сервисах, а поведение расходится.

— settings.py без границ: общие, локальные и секреты смешаны в одном файле. Потом любой деплой превращается в ручную сборку конфигурации.

Лучше держать отдельные сервисы для логики, смотреть на queryset до попадания в шаблон и проверять границы входных данных в одном месте. Тогда Django остаётся быстрым не только в демо, но и в репозитории, который живёт годами.

7 мест в Django, где чаще всего прячутся медленные запросы и лишняя нагрузка

Если проект начал «тормозить», первым делом смотрят не на сервер, а на ORM. В Django проблемы обычно сидят в одном из пяти слоёв: лишние JOIN'ы, N+1, неправильный select_related/prefetch_related, тяжёлые annotate и фильтры по полям без индекса.

Самая частая ошибка — тянуть объекты в шаблон или сериализатор по одному. Один список пользователей превращается в десятки запросов к профилям, ролям и последним действиям. Лечится просто: заранее собирайте связи и проверяйте итоговый SQL через django-debug-toolbar или логирование запросов.

Второй источник боли — QuerySet, который выглядит невинно, но в цикле вызывает новые обращения к базе. Сюда же попадают count(), exists(), first() и len() в неправильном месте. Если операция нужна один раз, сохраните результат в переменную, а не заставляйте ORM повторять работу 🧩

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

Правило простое: сначала измеряйте число запросов, потом оптимизируйте код — в Django почти всегда есть быстрый фикс до того, как понадобится сложная рефакторинг-стратегия.

Python-скрипт ломается не в коде, а в входных данных и окружении

За неделю в репах чаще всего всплывают одни и те же ошибки: скрипт ждёт идеальный CSV, ходит в сеть без таймаутов и молча глотает исключения. В итоге локально всё «работает», а в cron, CI или на сервере — тишина и пустые файлы.

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

Для сетевых скриптов базовый набор такой: timeout на каждый запрос, retries только на временные ошибки, логирование статуса и тела ответа хотя бы на уровне ошибок. Если парсишь чужой сайт или API, не полагайся на стабильность структуры HTML или JSON — добавь проверки на отсутствие поля и fallback-ветку.

Ещё одна частая поломка — «тихий успех». Скрипт завершился без traceback, но ничего не сделал: не нашёл строк, не создал папку, не сохранил файл. Поэтому в конце полезно печатать короткий итог: сколько строк прочитано, сколько записано, сколько пропущено.

Если у скрипта есть только одна точка контроля, она должна быть в начале: валидация входа и явный fail fast. Так отлавливаются 80% проблем раньше, чем они доедут до продакшена.

Арбитраж на вертикаль астрологии: как начать с ней работать

Астрология — белая вертикаль с низким порогом входа для CPA-арбитража. Можно создать собственного астробота через конструктор или нейросеть, подключив платежи через сервисы вроде Tribute, либо работать через партнёрки с готовыми ботами и SP-офферами. Также доступны нишевые площадки типа Bongacams с эзотериками (A. W. Empire). Трафик заливают со стандартных источников без клоачинга — Яндекс Директ, МТС Ads, ВК. Вертикаль привлекательна скромной к…

➡️ Читайте на сайте: https://aff.top/blog/arbitrazh-na-vertikal-astrologii-kak-nachat-s-nei-rabotat

🧠 Ещё больше инсайтов → в канале AFF.top

Starlette ломают не роуты, а мелкие ошибки в асинхронной обвязке

Starlette любят за минимализм: ASGI, middleware, роутинг, фоновые задачи — без лишней магии. Но на практике проект чаще всего тормозит не фреймворк, а то, как в нём пишут обработчики и подключают зависимости.

Проверьте базу:
— в async-endpoint не вызывайте тяжёлый sync-код напрямую, иначе блокируете event loop;
— для CPU-bound и долгих I/O выносите работу в отдельные процессы или очереди;
— middleware держите короткими: каждый лишний шаг проходит через весь запрос;
— не плодите глобальное состояние, если приложение масштабируется в несколько воркеров.

Ещё одна типовая ошибка — смешивать быстрый API и тяжёлую бизнес-логику в одном слое. Starlette хорошо подходит как тонкий HTTP-слой, а сложные сценарии лучше уводить в сервисы, фоновые задачи или отдельные модули. Так проще тестировать, менять транспорт и не тащить веб-детали в доменную часть.

Если нужен каркас без лишнего шума, Starlette берут именно за это: ясный поток запроса, предсказуемая асинхронность и минимум скрытого поведения. Начните с чистых handlers, затем отдельно проверьте middleware, блокировки и точки, где sync-код случайно попал в async-путь.

Scrapy ломается не на парсинге, а на мелочах вокруг него

Если проект на Scrapy начинает «сыпаться», почти всегда виноваты не селекторы, а обвязка: middleware, пайплайны, лимиты, cookies и состояние между запросами. Это нормальная история для любого краулера, который живёт дольше одного тестового прогона.

Что стоит проверять первым:
— timeout и retry: иначе ошибки сети маскируются под «пустой сайт»
— duplicate filter: если URL похожи, но query-параметры разные, можно потерять часть данных
— depth и allowed_domains: легко выстрелить себе в ногу и уйти в лишний обход
— item pipeline: именно здесь часто теряются поля, а не в parse-методе

Ещё одна типовая ошибка — писать логику как для requests-парсера. В Scrapy ответ приходит асинхронно, и порядок обработки не гарантирован. Если в spider копится состояние, храните его аккуратно: через meta, отдельные структуры или внешнее хранилище, а не через «глобальную переменную на всё».

И держите в голове простое правило: если нужно быстро понять, где проблема, смотрите на stats, логи ошибок и сырой response, а не сразу переписывайте XPath. Обычно это экономит больше времени, чем любой рефакторинг.

Автоматизация ломается не на коде, а на мелочах вокруг него

Если скрипт «иногда работает», почти всегда проблема не в Python, а в допущениях: файл уже готов, API отвечает всегда, формат не меняется, задача запускается только вручную. Автоматизация живёт там, где каждый из этих пунктов может сломаться в любой момент.

Перед тем как отдавать скрипт в cron, очередь или CI, проверь четыре вещи:
— идемпотентность: повторный запуск не должен дублировать данные;
— таймауты и ретраи: зависшие запросы не должны вешать весь процесс;
— валидация входа: пустой CSV, битый JSON и лишняя колонка не должны валить пайплайн;
— логирование: по логу должно быть ясно, на каком шаге всё упало.

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

И ещё одна типовая ошибка: смешивать бизнес-логику и запуск. Когда в одном файле и парсинг, и отправка, и запись, и планировщик, поддержка становится дороже самой задачи. Разносите на функции, а точку входа держите тонкой.

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

5 ошибок в Django, которые тихо ломают проект после первых 10 экранов

— Логика размазывается по views: в итоге один endpoint и валидирует, и считает, и пишет в БД. Лучше сразу выносить бизнес-правила в сервисы или model methods, а view оставлять тонким слоем.
— Сигналы используют как универсальный клей. Для простых реакций это ок, но для важной бизнес-логики сигнал плохо читается и тяжело тестируется.
— На проде надеются на автогенерацию SQL из моделей и забывают про индексы, уникальные ограничения и select_related/prefetch_related. Потом лечат не баги, а медленные страницы.
— settings.py превращают в свалку констант. Нормальная схема — разделять конфиг по окружениям и хранить секреты отдельно, а не по привычке в репозитории.

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

Если держать view тонкими, бизнес-логику — в отдельном слое, а запросы к БД — под контролем, Django остается быстрым в разработке и не разваливается под нагрузкой.

7 ошибок в автоматизации Python-скриптов, из-за которых всё ломается на ровном месте

Автоматизация выглядит просто, пока скрипт не упирается в реальный процесс: кривые входные данные, гонки за файл, повторный запуск и тихие падения без алерта.

• Нет идемпотентности: повторный запуск создаёт дубли вместо безопасного пересчёта.
• Нет явных границ ввода: скрипт принимает «что угодно» и падает на одном пустом поле.
• Нет логов на ключевых шагах: в проде видно только факт ошибки, а не её причину.
• Нет таймаутов и retry: внешние API и БД иногда молчат, а задача висит до ручного убийства.

Ещё одна частая проблема — смешивать бизнес-логику и инфраструктуру. Когда парсинг, запись в БД, ретраи и формат отчёта сидят в одном файле, любой фикс превращается в риск. Разносите на функции с одной ответственностью: отдельно валидация, отдельно действия, отдельно публикация результата.

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

Хороший automation-процесс начинается не с кода, а с правил: что можно повторить, что логировать и где остановиться без вреда.

Скрипт на Python ломается не в коде, а в границах входа, логов и ошибок

Если пишете утилиту «на один вечер», всё равно начинайте с трёх вещей: нормальный CLI, явные коды выхода, понятные сообщения об ошибках. Скрипт без этого быстро превращается в магию, которую страшно запускать второй раз.

Дальше проверьте базовый набор:
— входные данные валидируются до основной логики;
— все сетевые и файловые операции завернуты в try/except на нужном уровне;
— временные файлы удаляются даже при падении;
— результат можно повторить без ручной чистки.

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

И ещё: не смешивайте бизнес-логику с I/O. Когда чтение файлов, запросы к API и трансформация данных живут в разных функциях, скрипт проще тестировать, переиспользовать и чинить без переписывания всего файла.

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

asyncio ломают не await, а хаотичная отмена и забытые ограничения по I/O

В проектах на Python event loop обычно «падает» не от самой асинхронности, а от плохой дисциплины: один код ждёт сеть, другой держит CPU, третий запускает сотни задач без лимита. В итоге получаются подвисания, утечки задач и странные таймауты.

Что проверять в первую очередь:
• все долгие I/O-операции должны быть неблокирующими;
• CPU-bound куски выносите из loop, иначе async превращается в имитацию;
• любую пачку задач ограничивайте семафором или пулом;
• таймаут ставьте на внешний вызов, а не только на весь запрос;
• отмену задач обрабатывайте явно, а не «на авось».

Ещё одна типовая ошибка — смешивать «fire and forget» с бизнес-логикой. Если задача важна, её нужно хранить, дожидаться результата и уметь повторить. Если не важна — отделяйте её в фон и не делайте вид, что она часть критического пути.

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

Если в async-сервисе всё «иногда тормозит», сначала ищите не баги в await, а места, где вы забыли лимит, timeout или отмену.

—
Если инструменты — твоя тема, посмотри @DevToolsRadarPro

Asyncio ломается не на await, а на плохом распределении задач и ожиданий

Есть наблюдение которое стоит проверить: большинство проблем с asyncio — это не «асинхронность не работает», а смешение трёх вещей в одном коде:
— CPU-bound работа внутри event loop
— блокирующие вызовы без выноса в executor
— десятки задач без контроля отмены и таймаутов

Если в корутине есть тяжёлая обработка данных, цикл замирает для всех остальных задач. Если внутри прячется requests, file I/O или sleep из sync-модуля, вы теряете смысл async. Если собрать всё через create_task и забыть про gather/return_exceptions, ошибки начнут всплывать там, где их уже никто не ждёт.

Нормальная схема простая:
— I/O держим в async-библиотеках
— тяжёлое CPU выносим отдельно
— на внешние вызовы ставим timeout
— все фоновые задачи привязываем к жизненному циклу запроса или воркера
— отмену обрабатываем явно, а не «пусть само закроется»

В проде asyncio выигрывает не магией скорости, а дисциплиной. Чем раньше вы отделите ожидание сети от вычислений и зададите правила отмены, тем меньше будет «подвисших» корутин и фантомных багов.

Scrapy ломается не на парсинге, а на архитектуре паука и пайплайна

За неделю в репах чаще всего всплывают одни и те же ошибки:
— в одном Spider смешаны поиск ссылок, нормализация и бизнес-логика;
— дубликаты ловят post factum, а не через request fingerprint и фильтры;
— retry и таймауты настроены, но нет понятной политики на 403/429;
— в pipeline пишут в БД по одной записи, хотя нужен батч.

Scrapy лучше живёт, когда каждая часть делает одну вещь: Spider только собирает Request и item, Item Loader приводит поля к виду, Pipeline валидирует и сохраняет, middleware решает транспортные проблемы. Тогда проще тестировать, а падение одного шага не превращает весь обход в хаос.

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

И отдельно про селекторы: если XPath можно заменить на более узкий и стабильный путь, делайте это. Scrapy не про «красивый код», а про повторяемый сбор данных без лишних сюрпризов. Сначала разделите обязанности, потом уже ускоряйте.

5 ошибок в Python-скриптах, из-за которых автоматизация ломается на ровном месте

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

— Не проверяют вход: пустой CSV, битый JSON, отсутствующий столбец, неожиданный None
— Пишут в файл без атомарной записи: процесс прервался, и рабочий файл уже испорчен
— Смешивают логику и I/O: потом невозможно нормально тестировать и переиспользовать код

Для скриптов, которые крутятся по cron, важно не только «запустилось», но и «понятно, почему не запустилось». Нужны явные коды выхода, нормальный лог на stderr/stdout и отдельная обработка сетевых ошибок, таймаутов и повторных попыток.

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

Если коротко: любой Python-скрипт для продакшена должен переживать грязный ввод, повторный запуск и частичный сбой. Тогда автоматизация перестаёт быть «магией» и становится инструментом, который можно поддерживать годами.

5 ошибок в Django, из-за которых проект начинает тормозить и пухнуть

За неделю в репах обычно всплывают одни и те же вещи: бизнес-логика в views, тяжёлые запросы в циклах, отсутствие индексов и «временно» оставленные raw SQL. Потом это превращается в медленный админ, долгие страницы и баги, которые сложно повторить.

— Логику лучше выносить в сервисы или model methods, а views держать тонкими.
— Для списков и связей почти всегда проверяйте select_related/prefetch_related, иначе ловите N+1.
— Индексы нужны не «на всякий случай», а под реальные фильтры и сортировки.
— Если задача повторяется, оформляйте её в management command или Celery-задачу, а не в ручной скрипт.

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

Если хотите, чтобы Django жил долго, держите один принцип: каждый слой делает свою работу и не тащит лишнее.