AIO Study

Гайд по нейросетям

2025-03-01T11:53:37.220Z

Сейчас продают любую информацию, даже самую базовую, выдавая её за "уникальные знания". Мы с этим не согласны. Вот, например, чуваки, которые учат писать промпты. Серьёзно? Продавать умение формулировать запрос — это уже перебор.

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

Главное — уметь чётко формулировать задачу.

Мы не против тех, кто реально делится опытом, например, учит строить проекты используя только нейронки. Это ценный контент, а вот продавать базовые вещи — scam.

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

Все примеры будут показаны на ChatGPT, но некоторые из советов будут приминимы и с другими нейронками.

Кастомные инструкции

Речь пойдёт о кнопке "Настроить ChatGPT". Если ты ни разу не замечал эту кнопку, то ты многое потерял.

Погнали посмотрим, что там есть внутри:

1. Как должен ChatGPT обращаться к вам?

Тут понятно, назови себя "Boy Next Door" или "My Master" для антуража.

2. Кем вы работаете?

Вот здесь уже интереснее. Укажи направление, в котором ChatGPT должен тебе помогать. Это не значит, что ему нужно знать, что ты каменщик и работаешь три дня без зарплаты. Просто напиши сферу, например, "Python Programmer", чтобы он лучше помогал тебе с запросами по этой теме.

3. Какими характеристиками должен обладать ChatGPT

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

Вот пример нашей инструкции (индивидуально):

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

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

Если тема касается заработка, то уделяй ей особое внимание.

Если в конце сообщения будет написано "Вопросы.", то задавай максимум уточняющих вопросов.

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

4. Что-нибудь еще, что ChatGPT должен знать о вас

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

Например:

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

Как получить ответ, который тебе нужен

Это самая важная часть. Возможно, ты слышал выражение: «Как корабль назовёшь, так он и поплывёт»? Здесь тот же принцип – чем чётче ты сформулируешь запрос, тем лучше будет ответ.

Разберём на примере: с чего ты можешь начать диалог?

Пример качественного промпта:

В этом чате ты копирайтер. Мне необходимо, чтобы ты писал статьи для моего ТГ-канала про самодисциплину. Сейчас хочу разобрать тему «Почему казик — зло». Я буду тебе кидать просто название темы либо её описание, а ты должен выдавать структурированную статью без делового стиля, внутри которой нужно делать нативные упоминания самодисциплины и добавить мотивацию в конце.

Из чего состоит этот промпт:

1. Использование правила "NoHello"

Ты, возможно, уже знаком с правилом "NoHello" – его суть в том, чтобы сразу писать свою проблему, не дожидаясь ответа на простое "Привет". С ChatGPT это правило особенно актуально, поэтому переходим сразу к делу.

2. Постановка роли ChatGPT в этом чате

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

3. Предупредить о том, что ты будешь скидывать в чат

Нейронка должна знать контекст будущих сообщений. Чётко опиши, что ты собираешься ей отправлять.

4. Описание формата ответа на твой запрос

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

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

База данных ChatGPT

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

Как эффективно использовать ChatGPT как базу данных

Вы, скорее всего, уже пишете себе заметки в избранное в Telegram. Здесь то же самое — просто скармливаете GPT инфу и потом работаете с ней.

Например: у вас появилась идея создать свой проект по продаже ковриков для мышки. Кидаете все мысли об этом проекте в GPT, что полезно прямо на старте. Потому что нейросеть поможет реализовать его ещё лучше, чем вы могли бы придумать сами.

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

Как это может помочь?

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

Как объяснить GPT свою идею?

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

Любое взаимодействие с памятью ChatGPT подстраивает его индивидуально под вас. Проще говоря, создаёте себе идеального друга-консультанта, который всегда в теме ваших проектов.

Упрощение жизни

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

Просто задаёшь вопрос — и сразу получаешь суть. Никакого долгого ресёрча, никаких "наткнулся на что-то похожее, а в итоге это совсем не то". Только чёткий, понятный ответ, который подходит именно под твою ситуацию.

Сравнение ChatGPT и Google в различных задачах

В вопросах индивидуального подхода ChatGPT будет намного пластичней, нежели Google. Чтобы увидеть разницу, предлагаем сравнить их на различных задачах.

Представь, что тебе нужно затронуть научную сферу.

Через Google

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

Через ChatGPT

ChatGPT сразу выдаст суть, подробно объяснит, как всё работает, и будет разбирать тему, пока ты полностью её не поймёшь. Причём на любом языке.

Плюс:

У ChatGPT есть крутая функция — DeepResearch, и мы без преувеличения скажем: это реальная имба. В ChatGPT эта фича доступна только по подписке, но ты можешь затраить её в нейронке Grok, там она доступна бесплатно.

Как это работает? Если интересно узнать подробней и наглядно, то можешь глянуть вот этот видос. А если интересно в кратце, то читай дальше.

Ты просто задаёшь запрос, например: "Как мне найти скрытое API сайта?". ChatGPT запускает глубокий ресёрч (отсюда и название) и начинает собирать воедино всю информацию по теме.

Он переберёт кучу источников, найдёт релевантные ссылки, зацепит важные моменты, погрузится в детали. Допустим, он увидит, что в теме фигурирует Network в Developer Tools — добавит это в контекст. Дальше пойдёт глубже: найдёт инфу о фильтрации XHR-запросов, инструментах, методах, нюансах.

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

• Что такое скрытое API?
• Как его находят?
• Какие инструменты использовать?
• Какие у каждого метода плюсы и минусы?
• На что обратить внимание, чтобы не ошибиться?

От А до Я. Полное погружение в тему, без воды и лишнего ресёрча.

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

Теперь рассмотрим на другом примере: трекинге каллорий в еде.

Как бы ты это сделал через Google

Тебе нужно было бы выяснить: что это за еда, если не знаешь, то думать над тем, что за ингридиенты в неё входят
Потом забиваешь свой запрос и смотришь результаты
Если ты ничего не нашёл, то пробуешь переписать запрос
Опять ничего? Ну все, гг, ты что ешь вообще?

Как это происходит через ChatGPT

Фоткаешь свой хавчик
Отправляешь изображение ChatGPT и пишешь запрос
Он думает над тем, что у тебя там на фотке и сверяет со своими знаниями
Выдает тебе сколько каллорий у тебя на тарелке
Если не то, то уточняешь вместе с ним и приходишь к ответу

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

Как бы ты это сделал через Google

Вспоминаешь слова и составляешь запрос
Видишь в результатах хрень
Сдаёшься

Как это происходит через ChatGPT

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

Главный тейк в том, что ты можешь использовать GPT буквально как ассистента, который знает всё. Google ограничен своим форматом — он лишь предоставляет сайты, на которых может быть нужная тебе информация. А GPT уже владеет всей этой информацией, и твоя задача — лишь вытащить её из него путём качественного запроса.

Какую нейронку и для чего юзать

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

ChatGPT

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

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

DeepSeek

Ранее считался скрытым "гемчиком", особенно до того, как ChatGPT открыл доступ к своей продвинутой модели o3-mini и o3-mini-high. Так как у него была доступна фича "думанья" абсолютно бесплатно. Сейчас же для обычного общения в браузере он не будет чем-то выделяться.

Из минусов можно отметить жёсткую цензуру, так как проект был разработан в Китае.

Однако есть и важное преимущество – дешёвые токены при использовании через API, что делает его хорошим выбором для автоматизированных решений и массовых задач.

Если же ты всё еще хочешь использовать DeepSeek, то тебе полагается +100 социальный кредит, миска риса и кошко девочка. Партия гордится твой выбор! 🇨🇳

Grok

Настоящая имба для кода – обходит большинство моделей в решении задач по программированию, а также крипты из-за его возможности читать X (ex-Twitter). Сильно выигрывает в понимании алгоритмов и выдаёт качественные решения. Однако его "думанье" может хромать и выдавать ответ хуже, чем при обычной генерации текста. Хотя, возможно, это только у нас такое.

Claude

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

Заключение

В общем, всё упирается в то, как ты взаимодействуешь с нейронкой. Чёткие задачи, дополнительные детали и контекст — и ChatGPT (или любой другой AI) будет разрывать в нужном тебе направлении. Запиши свои мысли, эксперименты и инсайты, чтобы потом работать с ними уже на полном автомате.

Если есть замечания по формату статьи или нехватка какой-то информации, то дай знать в комментах.

Как наш ученик заработал $50,000 на тестнете Berachain

2025-02-10T11:39:43.384Z

Кейс, который случился прямо вот только что. И еще раз доказывает – на любом рынке можно зарабатывать.

@smeshny пришёл на курс уже с базовыми навыками программирования. До этого он покупал софт у Askaer для ретродропов и пытался кастомизировать модули под себя. Однако быстро осознал, что без более глубоких знаний в web3 и структуре софта не получится масштабировать проекты.

– "Я уже экспериментировал с софтами от Askaer — покупал их для ретродропов, пытался переделывать модули под себя... Но всегда горело желание масштабировать проекты, а знаний мне явно не хватало."

@smeshny сфокусировался на тестнете Berachain и постоянно натыкался на кучу вопросов. Когда в очередной раз он закидал Askaer запросами по кастомизации, тот предложил: «Иди учись, раз у тебя столько идей» Так @smeshny стал одним из самых вовлечённых наших студентов.

«Меня зацепил Berachain. Я бесконечно спрашивал, как подправить софт под него, и Askaer сказал: ‘Чувак, иди на обуч, там всё подробно’. Видимо, столько вопросов ещё никто ему не задавал ))»

"Круто) А что тебе зашло больше всего в нашем курсе?"

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

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

При работе с Berachain у @smeshny возникла проблема: на сайт уходили некорректные байты, и он не мог их расшифровать.

"Чтобы проверить гипотезу, я обратился к куратору Олегу и отправил ему 1111 $BERA на тестовый кошелёк. И вот чудо — за пару часов он провёл 7 транзакций, исправил проблему и вернул остаток! Итог: Олег получил дроп в 70 BERA (примерно $1000 по хаях)!

Кроме того, почти сразу после этого я написал софт для автоматического получения токенов с крана в тестнете Bera и поделился им в нашей группе. Практически все участники канала начали пользоваться моим софтом — для меня это было интуитивно понятно, ведь я просто повторил аналогичный кейс, разобранный на курсе."

Как итог, у @smeshny было целых 1220 кошельков — 1000 он создавал для тестирования, а оставшиеся использовал для основных операций.

Результат превзошёл все ожидания: на 220 кошельках оказалось по 12–25 токенов, а на основном — целых 1200 токенов. Мульткол позволил ему заклеймить дроп всего за час.

При продаже токенов по цене от $8 до $12 за штуку он заработал около $50,000 на тестнете, не вложив ни копейки.

Что дальше?

Теперь @smeshny рассматривает более масштабные проекты. Он упоминает тестнет Hyperchain, хотя там «конченый эксплорер» и отрабатывают его единицы, — значит, есть поле для новых возможностей. Основной фокус остаётся на поиске проектов, где он сможет развиваться и применять свои навыки.

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

Даже $50,000, которые я заработал на тестнете, для меня — не конечный результат.

Настоящая ценность - в навыках и опыте, которые я получил, в удовольствии от работы над проектом и постоянном совершенствовании своего софта.»

Мы на самом деле гордимся, что у нас есть такие сильные ученики и они создают такие сильные кейсы.

Но при этом, если ты читаешь эту статью, а сам никогда не кодил и переживаешь, что у тебя не получится – не парься!

На нашем флагманском курсе WEB3 Python Разработчик всё начинается с нуля и идёт пошагово. Мы проведём тебя за руку, чтобы ты освоил web3-разработку и смог повторять (а то и превосходить) такие результаты. Всё, что нужно, — желание учиться и действовать.

Готов ли ты сделать первый шаг? Пиши в нашу службу заботы @aio_supp – мы ответим на все твои вопросы, проконсультируем и покажем, как сейчас вообще можно зарабатывать на крипто-рынке

Гайд на Chrome профиля

2025-02-09T14:29:32.975Z

Привет! В этом гайде мы рассмотрим как из Chrome профилей сделать антидетект браузер. Сделаем мы это буквально за два расширения и немножко покопавшись в настройках браузера для фулл сейфти ворка.

Создание профиля

Открываем хром и создаем профиль

Кастомизируем профиль

Переходим по ссылке: chrome://settings/manageProfile

Здесь мы можем закастомить наш профиль, указав ему: нейм, цвет темы и аву.

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

Настройка профиля

Синхронизация

Далее проходимся по настройкам. Их придется выставлять на каждый из профилей отдельно, так как у хром нет функции синхронизации настроек, тоже самое и с расширениями.

Переходим на: chrome://settings/syncSetup

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

Сохранение данных

Переходим по очереди на каждую из ссылок:

chrome://settings/autofill

chrome://password-manager/settings

Отключайте всё, что только можно — нам не нужно, чтобы какие-либо данные сохранялись. Вдруг у вас есть вирусняк, который может их украсть.

А если нужно хранить пароли, то лучше делать это в менеджере паролей, например KeePassXC — он хранит всё локально на устройстве в зашифрованном виде и ничего никуда не отправляет.

Приватность

Переходим по всем вкладкам настроек и отключаем всё, что может угрожать вашей приватности. Включаем такие опции, как «Использовать только HTTPS», «Отправлять запрос "Do Not Track"» и другие подобные настройки.

Startup

Идем сюда: chrome://settings/onStartup

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

Расширения

Переходим к расширениям, а начнем с самого главного.

Trace

Скачать расширение из магазина Chrome

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

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

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

Вкладка Main Protections:

Вкладка Advanced Protections

SwitchyOmega

Скачать расширение из магазина Chrome

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

Заходим в настройки расширения и слева выбираем proxy. Далее вставляешь данные от прокси. Логин и пароль можно указать нажав на замок.

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

🔗 Понравился гайд? Тогда сохраняй и делись статьей с корешами!

AIO Study | Site

Разбор парсера Solana, EVM щитков

2025-01-27T11:10:11.882Z

Вот и разбор нашего парсера щитков! Когда мы впервые рассказали о нем, мы и представить не могли, что он вызовет такой сильный отклик. Спасибо всем, кто проявил интерес к нашей работе ❤️

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

Что делает наш парсер?

Наш скрипт обрабатывает список никнеймов аккаунтов X (ex-Twitter) из файла usernames.txt. Он последовательно проходит по каждому аккаунту, анализируя последние пять постов на наличие Solana или EVM контракта — проверяя как текст, так и изображения.

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

Когда все аккаунты обработаны, скрипт переходит в режим ожидания до следующего парсинга.

Что ты должен уметь?

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

Также ознакомься с нашей первой статьей, в которой мы подробно объясняем, как установить Python, настроить VS Code и написать свой первый скрипт. В другой статье рассказывается, как создать скрипт для распределения баланса с OKX на кошельки, включая работу с API, HTTP, HMAC и другое.

Где посмотреть код скрипта?

Весь исходный код парсера доступен на GitHub

Что такое классы

Перед тем как начать разбор, мы должны разобраться с тем, что такое классы.

Классы — это чертежи (шаблоны)для создания объектов. Они позволяют объединять данные (переменные) и функции (методы), работающие с этими данными, в одно целое.

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

Ты можешь создать класс для описания такого персонажа. Например:

class Character:
    def __init__(self, name, health, strength):
        self.name = name
        self.health = health
        self.strength = strength

    def attack(self, enemy):
        print(f"{self.name} атакует {enemy.name} с силой {self.strength}!")
        enemy.health -= self.strength

    def heal(self):
        print(f"{self.name} лечит себя!")
        self.health += 10

Здесь класс Character описывает персонажа с его характеристиками и действиями.

Теперь погнали создадим объект этого персонажа и повзаимодействуем с ним:

hero = Character("Герой", 100, 15)
villain = Character("Злодей", 80, 10)

hero.attack(villain)
villain.heal()

Мы создаем переменные hero и villain, каждая из которых является экземпляром класса Character. При создании объекта передаем имя персонажа, его здоровье и силу. При вызове класса срабатывает его конструктор, который создает объект и возвращает его. Полученные объекты мы сохраняем в переменные и затем используем их для взаимодействия.

Пока можешь не вдаваться в подробности кода, так как мы еще разберем это все при дальнейшем разборе парсера.

Функции НЕ хуже классов

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

Если бы тебе нужно было просто посчитать урон, который наносит персонаж врагу, то проще было бы использовать функцию, например:

def calculate_damage(attack, defense):
    return attack - defense

Зачем создавать сложный класс, если у тебя есть простая задача, которая не требует хранения состояния объектов и взаимодействия между ними?

Смотрим на структуру скрипта

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

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

Файлы:

main.py: Главный исполняемый файл проекта. Именно с него начинается выполнение софта. В этом файле происходит инициализация необходимых компонентов и запуск основных процессов парсинга.

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

utils.py: Файл с вспомогательными функциями и утилитами, которые используются в разных частях проекта.

requirements.txt: Список зависимостей проекта. В этом файле перечислены все внешние библиотеки и модули, которые необходимы для корректной работы скрипта.

x_usernames.txt: Текстовый файл, содержащий список имен пользователей X.

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

modules/parser.py: Обрабатывает твиты полученные из модуля x.py, извлекает из них контрактные адреса (из текста или изображений), используя utils.py и отправляет уведомления пользователю через telegram.py

modules/telegram.py: Отправляет сообщения в Telegram-чат, используя API Telegram.

modules/tweet_id_storage.py: Отвечает за сохранение и извлечение идентификаторов последнего обработанного твита для каждого пользователя в JSON формате.

modules/x.py: Модуль для взаимодействия с API X, обрабатывая запросы для получения данных о пользователях и их твитах.

Почему так:

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

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

Приступаем к разбору кода

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

settings.py

Начнем с чего-то простого, например, с конфигурационного файла.

Этот файл содержит настройки для работы парсера. В нем определены параметры прокси (PROXY), поведение парсинга (MAX_RETRIES, CHECK_RETWEETS, PARSING_INTERVAL_MINUTES), а также доступ к API X (Twitter) через BEARER_TOKEN. Кроме того, файл включает настройки для отправки уведомлений в Telegram (TELEGRAM_BOT_TOKEN, TELEGRAM_CHAT_ID).

# Proxy
PROXY = (
    "scheme://username:password@host:port"  # оставь как есть, если прокси не нужен
)

# Parse settings
MAX_RETRIES = 3  # сколько раз повторять парсинг при ошибках
CHECK_RETWEETS = True  # проверять ли ретвиты на наличие контрактов (увеличивает количество запросов)
PARSING_INTERVAL_MINUTES = 60 # сколько минут ждать после прохода всех аккаунтов перед повторным парсингом

# X settings
BEARER_TOKEN = "your_bearer_token"

# Telegram settings
TELEGRAM_BOT_TOKEN = "your_bot_token"
TELEGRAM_CHAT_ID = "your_chat_id"

Пояснение к коду:

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

main.py

Этот файл содержит основной код для запуска парсинга. Он загружает список имен пользователей из файла x_usernames.txt и периодически выполняет их обработку с помощью парсера (класс XParser). После завершения парсинга всех аккаунтов скрипт делает паузу на заданное время, а затем снова выполняет парсинг аккаунтов.

from time import sleep

from modules.parser import XParser
from settings import PARSING_INTERVAL_MINUTES


def main() -> None:
    parser = XParser()

    with open("x_usernames.txt", "r") as file:
        usernames = file.readlines()

    while True:
        for username in usernames:
            print(f"Начат парсинг аккаунта {username.strip()}")
            parser.parse_account(username.strip())
            print(f"Завершен парсинг аккаунта {username.strip()}")

        print(
            f"Парсинг завершен. Ждем {PARSING_INTERVAL_MINUTES} минут до следующего парсинга..."
        )
        sleep(PARSING_INTERVAL_MINUTES * 60)


if __name__ == "__main__":
    main()

Пояснение к коду:

1. Импорты

from time import sleep
from modules.parser import XParser
from settings import PARSING_INTERVAL_MINUTES

parser = XParser()

sleep — встроенная функция, приостанавливающая выполнение программы (используется для задержки между циклами).
XParser — класс для парсинга аккаунтов (код находится в modules/parser.py).
PARSING_INTERVAL_MINUTES — настройка, определяющая интервал ожидания перед следующим запуском (берётся из settings.py)

2. Функция main()

def main() -> None:

Создаем функцию main(), которая будет описывать основную логику работы программы.

Знак -> и любой тип данных за ним (как в нашем примере -> None) означает, что функция возвращает результат с типом None.

Создание объекта парсера

parser = XParser()

Создаем объект parser, используя класс XParser, тот самый шаблон, по которому строится объект. Когда мы его вызываем, то у нас создается объект XParser и записывается в переменную parser.

Ты еще увидишь класс XParser далее, когда будем разбирать модуль parser.py

Чтение списка пользователей

with open("x_usernames.txt", "r") as file:
    usernames = file.readlines()

Файл x_usernames.txt открывается в режиме чтения ("r"), а все строки загружаются в список usernames. Использование with open(...) автоматически закрывает файл после завершения работы с ним.

Бесконечный цикл

while True:

Запускаем бесконечный цикл, который работает, пока скрипт не остановят вручную (Ctrl + C) или не произойдет какое нибудь событие, которые заставит скрипт выйти из цикла. В нашем же случае, мы будем ждать пока пользователь сам не остановит скрипт.

Обработка каждого пользователя

for username in usernames:

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

Парсинг аккаунтов

print(f"Начат парсинг аккаунта {username.strip()}")
parser.parse_account(username.strip())
print(f"Завершен парсинг аккаунта {username.strip()}")

Метод username.strip() удаляет лишние пробелы и символы \n. Затем выводится сообщение о начале парсинга, после чего запускается метод parse_account() для обработки аккаунта. По завершении парсинга отображается сообщение об окончании процесса.

Ожидание перед следующим циклом

print(f"Парсинг завершен. Ждем {PARSING_INTERVAL_MINUTES} минут до следующего парсинга...")
sleep(PARSING_INTERVAL_MINUTES * 60)

Выводится сообщение о завершении итерации, затем программа делает паузу (sleep) на указанное количество минут. Мы умножаем PARSING_INTERVAL_MINUTES на 60, так как sleep() ожидает время в секундах

3. Запуск программы

if __name__ == "__main__":
    main()

Этот блок гарантирует, что main() запустится только если скрипт выполняется напрямую (python main.py), а не импортируется как модуль (import main).

utils.py

Здесь, как мы упомянали ранее, хранятся вспомогательные функции. Мы их будем использовать в модуле parser.py

В частности, здесь лежат функции по поиску адресов в тексте и картинке:

Поиск адреса контракта:
Функция анализирует текст, чтобы найти адреса контрактов Ethereum или Solana. Если такой адрес находится, он возвращается, иначе функция сообщает, что адресов нет.

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

import re
from io import BytesIO

import pytesseract
import requests
from PIL import Image


def get_contract_address(text: str = "") -> str | None:
    evm_pattern = r"0x[a-fA-F0-9]{40}"
    solana_pattern = r"[1-9A-HJ-NP-Za-km-z]{32,44}"

    evm_match = re.search(evm_pattern, text, re.MULTILINE | re.IGNORECASE | re.DOTALL)
    solana_match = re.search(
        solana_pattern, text, re.MULTILINE | re.IGNORECASE | re.DOTALL
    )

    if evm_match:
        return evm_match.group(0)
    elif solana_match:
        return solana_match.group(0)
    else:
        return None


def extract_text_from_image(image_url: str) -> str:
    with requests.request("GET", image_url) as response:
        img = Image.open(BytesIO(response.content))

    text = pytesseract.image_to_string(img)

    return text

Пояснение к коду:

1. Импорты

import re
from io import BytesIO

import pytesseract
import requests
from PIL import Image

re — модуль для работы с регулярными выражениями.
BytesIO — позволяет работать с бинарными данными в оперативной памяти, как с файловым объектом.
pytesseract — библиотека для распознавания текста на изображениях с помощью Tesseract OCR.
requests — библиотека для выполнения HTTP-запросов.
PIL.Image — класс из библиотеки Pillow, используется для работы с изображениями.

2. Функция get_contract_address()

def get_contract_address(text: str = "") -> str | None:

Эта функция ищет и извлекает из переданного текста адреса контрактов EVM и Solana.

Регулярные выражения для поиска

Регулярное выражение — это специальный шаблон для поиска текста в строках. Это своего рода "поиск по маске", который может быть очень гибким. Например, регулярка может искать все числа в тексте или проверять, соответствует ли строка конкретному формату (например, email-адресу).

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

Вернемся к коду:

evm_pattern = r"0x[a-fA-F0-9]{40}"
solana_pattern = r"[1-9A-HJ-NP-Za-km-z]{32,44}"

evm_pattern — шаблон для EVM-адресов (начинается с 0x и содержит 40 шестнадцатеричных символов).
solana_pattern — шаблон для Solana-адресов (от 32 до 44 символов, исключая некоторые буквы, чтобы избежать ошибок в идентификации).

Поиск адресов в тексте

evm_match = re.search(evm_pattern, text, re.MULTILINE | re.IGNORECASE | re.DOTALL)
solana_match = re.search(
    solana_pattern, text, re.MULTILINE | re.IGNORECASE | re.DOTALL
)

re.search() ищет первое совпадение с регулярным выражением в строке.

Флаги MULTILINE, IGNORECASE, DOTALL обеспечивают поиск по всему тексту без учёта регистра. Они объединяются с помощью |, что позволяет применять сразу несколько флагов в одном вызове функции.

Возврат найденного адреса

if evm_match:
    return evm_match.group(0)
elif solana_match:
    return solana_match.group(0)
else:
    return None

Мы проверяем, есть ли результат для каждого поиска по регулярному выражению. Если evm_match содержит результат, то возвращаем первый найденный адрес. Если же нет, проверяем solana_match. В случае, когда ни одно из поисков не дало результата, возвращаем None.

3. Функция extract_text_from_image()

def extract_text_from_image(image_url: str) -> str:

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

Загрузка изображения

with requests.request("GET", image_url) as response:
    img = Image.open(BytesIO(response.content))

Метод requests.request("GET", image_url) выполняет HTTP-запрос для загрузки изображения. Затем BytesIO(response.content) преобразует полученные бинарные данные в файловый объект. После этого Image.open(...) открывает изображение с помощью библиотеки Pillow.

Распознавание текста

text = pytesseract.image_to_string(img)

Чтобы извлечь текст с изображения, нужно воспользоваться сторонней библиотекой, такой как pytesseract.

Функция pytesseract.image_to_string(img) использует Tesseract OCR для распознавания текста.

Tesseract OCR — это инструмент, который читает текст с изображений и преобразует его в текстовый формат.

Возврат результата

return text

Функция возвращает распознанный текст в виде строки.

modules/parser.py

Модуль parser.py использует другой модуль, x.py, для взаимодействия с API платформы X (Twitter). Он использует методы этого модуля для получения информации о пользователе, его твитах и медиафайлах, а затем анализирует твиты на наличие контрактов в тексте или изображениях.

from typing import List

from modules.telegram import send_message_to_user
from modules.tweet_id_storage import TweetIdStorage
from modules.x import XAPIHandler
from settings import CHECK_RETWEETS
from utils import extract_text_from_image, get_contract_address


class XParser:
    def __init__(self):
        self.x_api_handler = XAPIHandler()
        self.tweet_id_storage = TweetIdStorage()

    def parse_account(self, username: str) -> None:
        user_id = self.x_api_handler.fetch_user_id_by_username(username)
        fetched_tweets = self.x_api_handler.fetch_user_tweets(username, user_id)

        if not fetched_tweets.get("data"):
            print(f"Нет новых твитов от {username}")
            return

        for tweet in reversed(fetched_tweets["data"]):
            if CHECK_RETWEETS and tweet.get("referenced_tweets"):
                for ref_tweet in tweet["referenced_tweets"]:
                    ref_tweet = self.x_api_handler.get_tweet_by_id(ref_tweet["id"])
                    ref_tweet_data = ref_tweet.get("data", {})

                    media = ref_tweet.get("includes", {}).get("media", [])

                    image_urls = []
                    for media_item in media:
                        if media_item.get("url"):
                            image_urls.append(media_item["url"])

                    self._process_tweet(
                        username,
                        ref_tweet_data["id"],
                        ref_tweet_data.get("note_tweet", {}).get("text")
                        or ref_tweet_data.get("text", ""),
                        image_urls,
                    )
            else:
                self.tweet_id_storage.save_last_tweet_id(username, tweet["id"])

                media = fetched_tweets.get("includes", {}).get("media", [])
                media_keys = tweet.get("attachments", {}).get("media_keys", [])

                image_urls = []
                for media_item in media:
                    if media_item["media_key"] in media_keys and media_item.get("url"):
                        image_urls.append(media_item["url"])

                self._process_tweet(
                    username,
                    tweet["id"],
                    tweet.get("note_tweet", {}).get("text") or tweet.get("text", ""),
                    image_urls,
                )

    def _process_tweet(
        self,
        username: str,
        tweet_id: str = "",
        tweet_text: str = "",
        image_urls: List[str] = [],
    ) -> None:
        if contract := get_contract_address(tweet_text):
            self._notify_contract_found(contract, username, tweet_id, "text")
            return

        for image_url in image_urls:
            image_text = extract_text_from_image(image_url)
            if contract := get_contract_address(image_text):
                self._notify_contract_found(contract, username, tweet_id, "image")

    def _notify_contract_found(
        self, contract: str, username: str, tweet_id: str, source: str
    ) -> None:
        tweet_url = f"https://x.com/{username}/status/{tweet_id}"

        if source == "text":
            message = f"Контракт найден в тексте твита: `{contract}`\n\n[Ссылка на твит]({tweet_url})"
        else:
            message = f"Контракт найден в изображении твита и может быть неправильным: `{contract}`\n\n[Ссылка на твит]({tweet_url})"

        send_message_to_user(message)

Пояснение к коду:

1. Импорты

from typing import List

from modules.telegram import send_message_to_user
from modules.tweet_id_storage import TweetIdStorage
from modules.x import XAPIHandler
from settings import CHECK_RETWEETS
from utils import extract_text_from_image, get_contract_address

List из typing — для аннотации типов данных.
send_message_to_user — функция для отправки сообщений пользователям.
TweetIdStorage — класс для хранения ID обработанных твитов.
XAPIHandler — класс для работы с API X.
CHECK_RETWEETS — настройка из settings, указывающая, нужно ли проверять ретвиты.
extract_text_from_image — функция для извлечения текста из изображений.
get_contract_address — функция для поиска контрактных адресов в тексте.

2. Класс XParser

class XParser:

Этот класс является шаблоном для создания объектов, отвечающих за парсинг твитов.

Инициализация класса

def __init__(self):
    self.x_api_handler = XAPIHandler()
    self.tweet_id_storage = TweetIdStorage()

При создании объекта XParser автоматически вызывается его конструктор __init__(), который инициализирует необходимые компоненты:

self.x_api_handler = XAPIHandler() — создаётся объект для работы с API X. Класс XAPIHandler является основным для взаимодействия с этим API.
self.tweet_id_storage = TweetIdStorage() — создаётся объект для работы с "базой данных" (обычный JSON файл), в котором хранятся последние ID твитов для каждого аккаунта. С помощью этого объекта мы можем сохранять и читать последние ID твитов.

Немного про __init__ и атрибуты:

В методе __init__() мы задаём атрибуты для объектов, используя префикс self., чтобы привязать их к конкретному экземпляру класса. Такие атрибуты являются уникальными для каждого экземпляра: изменение значения, например, self.a в одном объекте, не повлияет на значение этого атрибута в другом объекте, даже если они принадлежат одному классу.

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

3. Метод parse_account()

def parse_account(self, username: str) -> None:

Этот метод получает и обрабатывает твиты пользователя.

Получение твитов

user_id = self.x_api_handler.fetch_user_id_by_username(username)
fetched_tweets = self.x_api_handler.fetch_user_tweets(username, user_id)

Получаем user_id по username, затем загружаем список твитов пользователя. Для этого мы используем объект x_api_handler класса XAPIHandler

Проверка новых твитов

if not fetched_tweets.get("data"):
    print(f"Нет новых твитов от {username}")
    return

Если новых твитов нет, программа сообщает об этом и выходит из функции.

Проходимся по твитам

for tweet in reversed(fetched_tweets["data"]):

Проходим по списку твитов в обратном порядке (от старых к новым), чтобы обрабатывать их в хронологическом порядке.

Обработка ретвитов

if CHECK_RETWEETS and tweet.get("referenced_tweets"):
    for ref_tweet in tweet["referenced_tweets"]:
        ref_tweet = self.x_api_handler.get_tweet_by_id(ref_tweet["id"])
        ref_tweet_data = ref_tweet.get("data", {})
                    
        media = ref_tweet.get("includes", {}).get("media", [])
        image_urls = []
        for media_item in media:
            if media_item.get("url"):
                image_urls.append(media_item["url"])

Если CHECK_RETWEETS включен и твит является ретвитом, мы перебираем все ссылки на оригинальные твиты, получаем их ID и загружаем данные оригинального твита с помощью метода get_tweet_by_id(). Затем мы извлекаем его текст и проверяем, содержит ли он медиафайлы. Если у оригинального твита есть вложенные изображения, мы формируем список ссылок на них и передаём в дальнейшую обработку. Таким образом, если твит является ретвитом, мы анализируем не только сам ретвит, но и его оригинальный источник.

Структуру ответа API мы знаем из официальной документации X, что позволяет нам корректно обрабатывать данные, такие как referenced_tweets, media, text и другие ключи в JSON-ответе.

Обработка обычных твитов

else:
    self.tweet_id_storage.save_last_tweet_id(username, tweet["id"])

Если это не ретвит, сохраняем ID твита с помощью TweetIdStorage. Этот класс позволяет нам записывать и читать последние обработанные tweet_id из JSON-файла, который служит своеобразной базой данных. Это предотвращает повторную обработку уже разобранных твитов при последующих запусках.

Извлечение изображений

media = fetched_tweets.get("includes", {}).get("media", [])
media_keys = tweet.get("attachments", {}).get("media_keys", [])
image_urls = []
for media_item in media:
    if media_item["media_key"] in media_keys and media_item.get("url"):
        image_urls.append(media_item["url"])

Из полученного списка media извлекаем все элементы, у которых есть media_key, совпадающий с media_keys твита, и у которых присутствует поле url. Это позволяет нам получить только те изображения, которые действительно принадлежат данному твиту, а не другим вложенным элементам. Таким образом, мы формируем список image_urls, содержащий ссылки на изображения, прикреплённые к твиту.

Обработка твита

self._process_tweet(
    username,
    tweet["id"],
    tweet.get("note_tweet", {}).get("text") or tweet.get("text", ""),
    image_urls,
)

Передаём данные в _process_tweet().

4. Метод _process_tweet()

def _process_tweet(
    self,
    username: str,
    tweet_id: str = "",
    tweet_text: str = "",
    image_urls: List[str] = [],
 ) -> None:

Проверяет, есть ли контрактный адрес в тексте или на изображениях.

Поиск контракта в тексте

if contract := get_contract_address(tweet_text):
    self._notify_contract_found(contract, username, tweet_id, "text")
    return

Конструкция contract := get_contract_address(tweet_text) использует оператор моржового присваивания (:=), который одновременно присваивает значение переменной contract и проверяет его. Это эквивалентно записи:

contract = get_contract_address(tweet_text)
if contract:
    self._notify_contract_found(contract, username, tweet_id, "text")
    return

Если get_contract_address(tweet_text) вернёт не None, contract получит это значение, и условие выполнится. Это сокращает код и делает его компактнее.

Если контракт найден, вызываем _notify_contract_found() и выходим из функции.

Поиск контракта на изображениях

for image_url in image_urls:
    image_text = extract_text_from_image(image_url)
    if contract := get_contract_address(image_text):
        self._notify_contract_found(contract, username, tweet_id, "image")

Если контракт найден на изображении, отправляем уведомление.

5. Метод _notify_contract_found()

def _notify_contract_found(
    self, contract: str, username: str, tweet_id: str, source: str
) -> None:

Отправляет сообщение пользователю, если найден контракт.

Формирование URL твита

tweet_url = f"https://x.com/{username}/status/{tweet_id}"

Создаём ссылку на твит.

Формирование сообщения

message = f"Контракт найден в {'тексте' if source == 'text' else 'изображении'} твита: `{contract}`\n\n[Ссылка на твит]({tweet_url})"

Формируем сообщение в зависимости от того, где найден контракт. Отметим, что в f строках, помимо переменных, можно использовать и тернарный оператор (не пугайся, это просто if, else)

Отправка сообщения

send_message_to_user(message)

Отправляем уведомление пользователю в телеграм через функцию send_message_to_user() из модуля telegram.py

modules/telegram.py

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

import requests

from settings import TELEGRAM_BOT_TOKEN, TELEGRAM_CHAT_ID


def send_message_to_user(text: str = ""):
    requests.post(
        f"https://api.telegram.org/bot{TELEGRAM_BOT_TOKEN}/sendMessage?chat_id={TELEGRAM_CHAT_ID}&text={text}&parse_mode=Markdown"
    )

Пояснение к коду:

1. Импорты

import requests
from settings import TELEGRAM_BOT_TOKEN, TELEGRAM_CHAT_ID

Этот код импортирует:

requests — библиотеку для выполнения HTTP-запросов.
TELEGRAM_BOT_TOKEN и TELEGRAM_CHAT_ID — настройки, которые хранят токен бота и ID чата, куда отправляются сообщения.

2. Функция send_message_to_user()

def send_message_to_user(text: str = ""):

Эта функция отвечает за отправку текстового сообщения пользователю через API Telegram.

Отправляем сообщение через requests

requests.post(
    f"https://api.telegram.org/bot{TELEGRAM_BOT_TOKEN}/sendMessage?chat_id={TELEGRAM_CHAT_ID}&text={text}&parse_mode=Markdown"
)

Для отправки сообщения используется метод requests.post(), который выполняет HTTP-запрос к Telegram API. В этом запросе формируется URL, содержащий токен бота и параметры, необходимые для отправки сообщения:

chat_id={TELEGRAM_CHAT_ID} — указывает, в какой чат должно быть отправлено сообщение. Этот ID привязан к пользователю или группе, в которой работает бот.
text={text} — передаваемый текст сообщения, который будет отображаться в чате.
parse_mode=Markdown — Telegram поддерживает форматирование Markdown, что позволяет выделять текст жирным (**жирный**), курсивом (_курсив_) или вставлять ссылки ([ссылка](https://example.com)).

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

modules/tweet_id_storage.py

Модуль tweet_id_storage.py отвечает за сохранение и получение идентификаторов последних твитов для каждого пользователя. Он использует локальный файл latest_tweets_id.json для хранения данных. Метод get_last_tweet_id позволяет получить идентификатор последнего твита для конкретного пользователя, а метод save_last_tweet_id сохраняет новый идентификатор твита в файл, обновляя информацию для указанного пользователя. Этот модуль обеспечивает отслеживание последних обработанных твитов, чтобы избежать повторной обработки тех же твитов.

import json
import os


class TweetIdStorage:
    LATEST_TWEETS_ID_PATH = "latest_tweets_id.json"

    def get_last_tweet_id(self, username: str) -> str:
        if os.path.exists(self.LATEST_TWEETS_ID_PATH):
            with open(self.LATEST_TWEETS_ID_PATH, "r") as file:
                data = json.loads(file.read())
        else:
            data = {}

        return data.get(username, None)

    def save_last_tweet_id(self, username: str, tweet_id: str):
        if os.path.exists(self.LATEST_TWEETS_ID_PATH):
            with open(self.LATEST_TWEETS_ID_PATH, "r") as file:
                data = json.loads(file.read())
        else:
            data = {}

        data[username] = tweet_id

        with open(self.LATEST_TWEETS_ID_PATH, "w") as file:
            file.write(json.dumps(data))

Пояснение к коду:

1. Импорты

import json
import os

Этот модуль импортирует два стандартных модуля Python:

json — библиотека для работы с JSON-данными, которая позволяет сериализовать (преобразовывать объекты Python в строковый формат JSON) и десериализовать (из JSON-строки обратно в объект Python). Мы используем её для хранения ID твитов в файле и работы с этим хранилищем как с обычным словарём.
os — модуль для работы с операционной системой, который предоставляет функции для взаимодействия с файловой системой. В данном случае он помогает нам проверять, существует ли файл latest_tweets_id.json, прежде чем пытаться его открыть. Это предотвращает ошибки при обращении к несуществующему файлу.

2. Класс TweetIdStorage

class TweetIdStorage:
    LATEST_TWEETS_ID_PATH = "latest_tweets_id.json"

Этот класс предназначен для сохранения и получения последнего ID твита, связанного с пользователем.

LATEST_TWEETS_ID_PATH — это классовый атрибут, который хранит имя JSON-файла, в котором сохраняются данные. Этот файл можно рассматривать как небольшую базу данных.

Что такое классовые атрибуты

Мы говорили, что рассмотрим классовые атрибуты при разборе этого модуля. Так вот, LATEST_TWEETS_ID_PATH — это тот самый атрибут. В отличие от обычных атрибутов, классовые атрибуты являются общими для всех объектов класса. Это значит, что если изменить значение атрибута, например, self.a, у одного объекта, оно изменится и у всех остальных объектов этого класса.

3. Функция get_last_tweet_id()

def get_last_tweet_id(self, username: str) -> str:

Эта функция загружает JSON-файл и получает последний сохранённый ID твита для конкретного пользователя.

Проверка файла на существование

if os.path.exists(self.LATEST_TWEETS_ID_PATH):

Сначала проверяется наличие файла latest_tweets_id.json с помощью функции os.path.exists. Эта функция принимает путь к файлу, и так как файл хранится в корне проекта, достаточно указать только его название, которое хранится в self.LATEST_TWEETS_ID_PATH

Чтение данных из файла

with open(self.LATEST_TWEETS_ID_PATH, "r") as file:
    data = json.loads(file.read())

Открываем файл в режиме чтения ("r"), затем с помощью file.read() считываем его содержимое в виде строки. После этого используем json.loads(), чтобы преобразовать JSON-формат в питоновский словарь. Теперь data содержит словарь, где ключи — это имена пользователей, а значения — ID их последних твитов.

else:
    data = {}

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

Возвращаемый результат

return data.get(username, None)

Функция ищет в словаре ключ с именем пользователя (username) и возвращает его значение (ID последнего твита). Если ключ отсутствует, возвращается None.

4. Функция save_last_tweet_id()

def save_last_tweet_id(self, username: str, tweet_id: str):

Эта функция сохраняет последний ID твита пользователя в JSON-файл.

Проверка файла на существование и чтение из него

if os.path.exists(self.LATEST_TWEETS_ID_PATH):
    with open(self.LATEST_TWEETS_ID_PATH, "r") as file:
        data = json.loads(file.read())

Как и в get_last_tweet_id(), сначала проверяется, существует ли JSON-файл. Если он есть, его содержимое загружается в виде словаря.

else:
    data = {}

Если файла нет, создаётся пустой словарь.

Обновляем ID последнего твита для юзера

data[username] = tweet_id

Далее в словарь добавляется/изменяется запись, где ключ — это имя пользователя, а значение — ID твита.

Записываем результат обратно в файл

with open(self.LATEST_TWEETS_ID_PATH, "w") as file:
    file.write(json.dumps(data))

Сначала обновлённый словарь с данными преобразуется в JSON-строку с помощью json.dumps(). Затем, используя file.write(), эта строка записывается в файл, открытый в режиме "w" (перезапись файла).

modules/x.py

Модуль x.py обеспечивает взаимодействие с API платформы X (Twitter). Он позволяет выполнять запросы для получения данных о пользователях, их твитах и конкретных твитах по идентификатору. Основные функции включают извлечение идентификатора пользователя по его имени, получение списка твитов пользователя с учетом ранее обработанных, а также получение информации о твите по его ID. Модуль обрабатывает лимиты запросов, поддерживает прокси и интегрируется с модулем tweet_id_storage.py для хранения последних обработанных твитов.

import time
from typing import Any, Dict

import requests

from modules.tweet_id_storage import TweetIdStorage
from settings import BEARER_TOKEN, MAX_RETRIES, PROXY


class XAPIHandler:
    BASE_URL = "https://api.x.com/2"

    def __init__(self):
        self.tweet_id_storage = TweetIdStorage()

    def _make_request(
        self,
        endpoint: str,
        method: str,
        data: Dict[str, Any] = {},
        params: Dict[str, str] = {},
    ) -> Dict[str, Any]:
        headers = {
            "Authorization": f"Bearer {BEARER_TOKEN}",
        }

        retries = 0
        while retries < MAX_RETRIES:
            try:
                response = requests.request(
                    method=method,
                    url=self.BASE_URL + endpoint,
                    headers=headers,
                    data=data,
                    params=params,
                    proxies={"http": PROXY, "https": PROXY}
                    if PROXY != "scheme://username:password@host:port"
                    else None,
                )
                response.raise_for_status()

                return response.json()
            except requests.exceptions.HTTPError as error:
                if error.response.status_code == 429:
                    reset_time = error.response.headers["X-Rate-Limit-Reset"]
                    time_to_wait = int(reset_time) - int(time.time())
                    print(
                        f"Превышено максимальное количество запросов. Подождите {time_to_wait} секунд"
                    )
                    time.sleep(time_to_wait)
                else:
                    print(error.response.text)
                    retries += 1

        raise Exception("Превышено максимальное количество попыток")

    def fetch_user_id_by_username(self, username: str) -> str:
        user = self._make_request(f"/users/by/username/{username}", method="GET")

        return user["data"]["id"]

    def fetch_user_tweets(self, username: str, user_id: str) -> Dict[str, Any]:
        last_tweet_id = self.tweet_id_storage.get_last_tweet_id(username)

        params = {
            "expansions": "attachments.media_keys,referenced_tweets.id",
            "media.fields": "url,type,media_key",
            "tweet.fields": "text,note_tweet",
        }

        if last_tweet_id:
            params["since_id"] = last_tweet_id
            params["max_results"] = "100"
        else:
            params["max_results"] = "5"

        return self._make_request(
            f"/users/{user_id}/tweets", method="GET", params=params
        )

    def get_tweet_by_id(self, tweet_id: str) -> Dict[str, Any]:
        params = {
            "expansions": "attachments.media_keys,referenced_tweets.id",
            "media.fields": "url,type,media_key",
            "tweet.fields": "text,note_tweet",
        }

        return self._make_request(f"/tweets/{tweet_id}", method="GET", params=params)

Пояснение к коду:

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

1. Импорты

import time
from typing import Any, Dict
import requests
from modules.tweet_id_storage import TweetIdStorage
from settings import BEARER_TOKEN, MAX_RETRIES, PROXY

Мы импортируем:

time — используется для работы с задержками (sleep).
Any и Dict из typing — используются для аннотации типов.
requests — библиотека для отправки HTTP-запросов.
TweetIdStorage — класс для чтение и добавления ID последних обработанных твитов.
BEARER_TOKEN, MAX_RETRIES, PROXY — настройки, используемые для работы с API X.

2. Класс XAPIHandler

class XAPIHandler:
    BASE_URL = "https://api.x.com/2"

Этот класс предназначен для взаимодействия с API X.

BASE_URL — это классовый атрибут, который доступен всем объектам класса XAPIHandler. Он задаёт базовый URL, к которому добавляются конечные точки API для формирования запросов.

Инициализация класса

def __init__(self):
    self.tweet_id_storage = TweetIdStorage()

При создании объекта класса XAPIHandler создаётся объект TweetIdStorage, который будет использоваться для чтения и сохранения ID последних твитов, чтобы избежать повторной обработки одних и тех же данных.

3. Метод _make_request()

def _make_request(
    self,
    endpoint: str,
    method: str,
    data: Dict[str, Any] = {},
    params: Dict[str, str] = {},
) -> Dict[str, Any]:

Этот метод выполняет HTTP-запросы к API X. Принимает следующие аргументы:

endpoint — конечная точка API, например, "/users/by/username/{username}". То есть, мы ожидаем, что это будет путь к X API, но без https://api.x.com/2, так как это у нас уже записано в self.BASE_URL
method — HTTP-метод (GET, POST и т. д.)
data — данные, передаваемые в теле запроса (по умолчанию пустой словарь)
params — параметры запроса, передаваемые в URL (по умолчанию также пустой словарь)

Формирование запроса

headers = {
    "Authorization": f"Bearer {BEARER_TOKEN}",
}

Добавляется заголовок Authorization, содержащий токен BEARER_TOKEN, который требуется для работы с API X.

Цикл с попытками запроса

retries = 0
while retries < MAX_RETRIES:

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

Отправка запроса

try:
    response = requests.request(
        method=method,
        url=self.BASE_URL + endpoint,
        headers=headers,
        data=data,
        params=params,
        proxies={"http": PROXY, "https": PROXY}
        if PROXY != "scheme://username:password@host:port"
        else None,
)
    response.raise_for_status()
    return response.json()

Отправляем HTTP-запрос по адресу, составленному из BASE_URL и переданного endpoint. Заголовки запроса включают авторизационный токен, который необходим для доступа к API.

Если PROXY указан, то он будет использоваться для маршрутизации запроса.

После отправки запроса вызывается response.raise_for_status(), который проверяет код ответа. Если сервер возвращает ошибку (например, 404 — не найдено или 500 — внутренняя ошибка), то мы вызываем исключение.

Если запрос выполнен успешно, выполняем response.json(), который преобразует ответ API в словарь Python.

Обработка ошибки "Слишком много запросов" (код 429)

except requests.exceptions.HTTPError as error:
    if error.response.status_code == 429:
        reset_time = error.response.headers["X-Rate-Limit-Reset"]
        time_to_wait = int(reset_time) - int(time.time())
        print(
            f"Превышено максимальное количество запросов. Подождите {time_to_wait} секунд"
        )
        time.sleep(time_to_wait)

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

Если API X отвечает кодом 429 (слишком много запросов), скрипт получает из заголовков ответа значение X-Rate-Limit-Reset, которое указывает, когда можно отправить следующий запрос.

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

Обработка других ошибок

else:
    print(error.response.text)
    retries += 1

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

Выход из while цикла

После того как retries превысит MAX_RETRIES, скрипт выходит из while цикла и вызывает исключение.

raise Exception("Превышено максимальное количество попыток")

4. Метод fetch_user_id_by_username

Этот метод получает ID пользователя по его username.

def fetch_user_id_by_username(self, username: str) -> str:
    user = self._make_request(f"/users/by/username/{username}", method="GET")
    return user["data"]["id"]

Выполняем запрос используя ранее описанный метод self._make_request(). В него мы передаем endpoint на который нужно сделать GET запрос для получения ID пользователя по его username.

Ответом от X API будет словарь, который содержит данные о пользователе. Из него мы вытаскиваем ID пользователя и возвращаем.

5. Метод fetch_user_tweets

def fetch_user_tweets(self, username: str, user_id: str) -> Dict[str, Any]:

Этот метод позволяет получить твиты пользователя. В качестве аргумента принимает username и user_id

Вытаскиваем ID последних постов

last_tweet_id = self.tweet_id_storage.get_last_tweet_id(username)

Сначала берём ID последнего сохранённого твита пользователя. Для этого используем уже знакомый нам self.tweet_id_storage.get_last_tweet_id() и передаем ему username аккаунта.

Указываем параметры запроса к X API

params = {
    "expansions": "attachments.media_keys,referenced_tweets.id",
    "media.fields": "url,type,media_key",
    "tweet.fields": "text,note_tweet",
}

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

expansions используется для включения связанных объектов, которые не входят в основной ответ API:

referenced_tweets.id — позволяет получать ретвиты и цитаты.
attachments.media_keys — включает идентификаторы медиафайлов, прикрепленных к твиту.

tweet.fields определяет, какие свойства твита должны быть включены в ответ API:

text — сам текст твита.
note_tweet — примечания к твиту.

Если твит содержит изображения, видео или GIF, то для получения информации о них используется media.fields:

media_key — уникальный идентификатор медиафайла.
type — тип медиа (photo, video, animated_gif).
url — ссылка на медиафайл (доступна для изображений).

Модифицируем параметры в зависимости от наличия last_tweet_id

if last_tweet_id:
    params["since_id"] = last_tweet_id
    params["max_results"] = "100"
else:
    params["max_results"] = "5"

Если есть last_tweet_id, берём твиты только после него (до 100 штук).
Если нет — просто берём последние 5 твитов.

Возвращаем результат

return self._make_request(f"/users/{user_id}/tweets", method="GET", params=params)

В качестве результата мы возвращаем ответ от запрос на GET /users/{user_id}/tweets, что вернет нам твиты пользователя

6. Метод get_tweet_by_id

def get_tweet_by_id(self, tweet_id: str) -> Dict[str, Any]:

Получаем информацию о конкретном твите, что пригодится при разборе ретвитов, так как их изображения не хранятся в ответе из fetch_user_tweets

Указываем параметры к запросу

params = {
    "expansions": "attachments.media_keys,referenced_tweets.id",
    "media.fields": "url,type,media_key",
    "tweet.fields": "text,note_tweet",
}

Снова указываем параматеры к запросу, они будут такими же как и в предыдущий раз.

Возвращаем результат

return self._make_request(f"/tweets/{tweet_id}", method="GET", params=params)

Делаем запрос на GET /tweets/{tweet_id} и возвращаем результат

Заключение

Мы разобрали наш парсер X аккаунтов от а до я. Надеемся вам все было понятно, а если нет, то го в комменты — ответим и поясним за любую строчку в коде.

Данный скрипт мы написали всего за один день. Да, пришлось попотеть с API X, но в целом код, ну очень простой. Поэтому не бойся и просто начинай писать. Никогда не будет всё чётко и гладко, главное быть готовым к трудностям.

📌 Сохраняй статью и делись с друзьями, пускай тоже прошарят за код

AIO Study | Site

Пишем софт по раскидыванию баланса с биржи

2025-01-19T15:28:40.895Z

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

Что будет делать написанный скрипт?

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

Что ты должен уметь?

Для понимания материала потребуется базовое знание синтаксиса Python. Если что-то будет непонятно, не бойся обратиться к ChatGPT за помощью.

Где я могу посмотреть код скрипта?

Ты можешь посмотреть и скачать наш код с GitHub репозитория.

Что такое API

Для написания софта нам понадобится работать с OKX API. Так что сначала разберемся с тем, что такое API.

API (Application Programming Interface) — Если упростить, то это набор инструментов, которые позволяют различным программам взаимодействовать друг с другом. В нашем случае API OKX — это способ для нашего софта взаимодействовать с биржей для выполнения операций, таких как вывод средств, просмотр баланса и так далее.

Пример

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

Получаем ключи для взаимодействия с OKX API

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

1. Переходим сюда и нажимаем "Create API key".

2. Заполняем поля и в Permissions указываем все возможные разрешения, иначе наш скрипт не сможет выводить или торговать токенами. Также можете указать список разрешенных IP для взаимодействия с API. После того как все заполнили жмём на "Submit all".

3. После создания нас вернет обратно. Тут нужно нажать на кнопку "view" рядом с созданным нами API ключем.

4. Теперь необходимо сохранить API-ключ как OKX_API_KEY, Secret key как OKX_API_SECRET, а также Passphrase, который ты указывал при создании API, как OKX_API_PASSPHRASE. Эти данные будут использованы позже.

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

Приступаем к созданию нашего фундамента для софта. Создаем папку, например, okx_spreader и открываем её в VS Code или другом редакторе кода. Далее создаем следующую структуру файлов:

Давай разберем каждый попунктно:

modules — директория, в которой хранятся модули для нашего скрипта, такие как okx.py и transfer.py. Эти модули будут реализовывать основную функциональность скрипта.
modules/okx.py — модуль, отвечающий за взаимодействие с API биржи OKX.
modules/transfer.py — модуль, который управляет выводом средств. Для каждого кошелька он инициирует вывод токенов используя okx.py модуль.
main.py — основной файл для запуска нашего софта.
recipients.txt — файл, содержащий список адресов, на которые будут переводиться токены.
settings.py — файл для хранения различных настроек, необходимых для работы скрипта.
utils.py — файл с вспомогательными функциями, которые могут быть использованы в разных модулях проекта.

Начинаем писать код

settings.py

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

TRANSFER_AMOUNT_RANGE — диапазон, в котором будет генерироваться сумма перевода (например, от 3 до 5). Это необходимо, чтобы сумма перевода была не фиксированной, а случайной в пределах заданного диапазона.
TRANSFER_CURRENCY — тип валюты, который будем переводить, в нашем случае это USDT.
TRANSFER_CHAIN — сеть, на которую будем инициировать перевод, например, Arbitrum One.
OKX_API_KEY, OKX_API_SECRET, OKX_API_PASSPHRASE — это параметры для аутентификации при работе с API биржи OKX. Помнишь я тебя попросил сохранить данные под определенным неймингом? Самое время будет их заполнить.

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

# transfer settings
TRANSFER_AMOUNT_RANGE = [3, 5]  # диапазон суммы перевода с OKX на кошелек
TRANSFER_CURRENCY = "USDT"  # токен для перевода (как записано на OKX)
TRANSFER_CHAIN = "Arbitrum One"  # сеть куда перевести (как записано на OKX)

# exchange settings
OKX_API_KEY = "your_okx_api_key"
OKX_API_SECRET = "your_okx_api_secret"
OKX_API_PASSPHRASE = "your_okx_api_passphrase"

main.py

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

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

from modules.transfer import start_transfer

def main():
    # Спрашиваем пользователя, хочет ли он начать раскидку баланса и сохраняем ответ в переменную choice
    choice = input("Начать раскидку баланса? [Y/N]: ")

    # Если пользователь ответил "YES" или "Y" (в любом регистре), то запускаем функцию start_transfer
    if choice.upper() in ["YES", "Y"]:
        start_transfer()
    else:
        print("Выход...")
        exit()


if __name__ == "__main__":
    main()

Пояснение к коду:

1. Импорт функции start_transfer:

from modules.transfer import start_transfer

Эта строка импортирует функцию start_transfer из модуля transfer, расположенного в папке modules. Функция start_transfer будет использоваться для страта вывода токенов с OKX на кошельки, указанные в файле recipients.txt

2. Определение функции main:

def main():

Функция main — это точка входа в вашу программу. Она будет управлять основным процессом взаимодействия с пользователем.

3. Получение ввода от пользователя:

choice = input("Начать раскидку баланса? [Y/N]: ")

Здесь мы просим пользователя ввести, хочет ли он начать процесс распределения баланса, и сохраняем его ответ в переменной choice.

4. Проверка ввода пользователя:

if choice.upper() in ["YES", "Y"]:

Мы проверяем, ввел ли пользователь "YES" или "Y", используя метод upper() для преобразования ввода в верхний регистр. Это делает проверку нечувствительной к регистру. Вместо нескольких отдельных условий, мы просто проверяем, содержится ли преобразованный ввод в списке ["YES", "Y"]. Например, если пользователь ввел "yes", метод upper() преобразует его в "YES", который присутствует в списке. Таким образом, условие выполняется, и мы попадаем внутрь блока if.

5. Вызов функции start_transfer:

Если пользователь ввел "YES" или "Y", мы вызываем функцию start_transfer, чтобы начать процесс распределения баланса.

start_transfer()

6. Обработка другого ввода:

Если пользователь ввел что-то другое, не "YES" или "Y", то мы выводим сообщение "Выход..." и завершаем программу с помощью стандартной функции exit().

else:
    print("Выход...")
    exit()

7. Запуск функции main:

В конце добавляется проверка, чтобы убедиться, что этот код выполняется только при непосредственном запуске файла, а не при его импорте как модуля. То есть, если файл запускается командой python main.py, а не импортируется через import main.py. Если условие выполняется, вызывается функция main

if __name__ == "__main__":
    main()

modules/transfer.py

Этот файл отвечает за сам процесс перевода средств. Мы будем читать список получателей (адресов кошельков) из файла recipients.txt. Для каждого получателя вызываем функцию withdraw(), которая выполнит перевод на конкретный кошелек через OKX API.

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

from modules.okx import withdraw

def start_transfer():
    with open("recipients.txt", "r") as file:
        recipients = file.readlines()
    
    for recipient in recipients:
        withdraw(recipient.strip())

Пояснение к коду:

1. Импорт функции withdraw:

Сначала мы импортируем функцию withdraw из модуля okx.py. Эта функция будет использоваться для выполнения вывода средств на указанные адреса используя функцию withdraw из okx.py

from modules.okx import withdraw

2. Определение функции start_transfer:

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

def start_transfer():

3. Чтение файла с адресами:

Мы используем контекстный менеджер with, чтобы открыть файл recipients.txt для чтения. Контекстный менеджер гарантирует, что файл будет закрыт автоматически, как только выполнение выйдет из блока with, независимо от того, произошла ли ошибка в процессе работы с файлом. Это делает код более безопасным и удобным, так как не нужно вручную закрывать файл.

Функция open используется для открытия файла. Она принимает два аргумента. Первый — это путь к файлу. В нашем случае файл называется recipients.txt и находится в той же папке, что и скрипт, поэтому достаточно указать только имя файла. Второй аргумент — это режим открытия файла. В данном случае мы используем "r", что означает режим чтения (read). Функция open возвращает объект файла, который мы сохраняем в переменной file.

Файл recipients.txt должен содержать список адресов получателей, где каждый адрес находится на новой строке. Мы считываем все строки файла с помощью метода readlines(), который возвращает список, где каждая строка файла становится отдельным элементом списка.

with open("recipients.txt", "r") as file:
    recipients = file.readlines()

4. Цикл по списку адресов:

Мы перебираем все адреса из списка recipients с помощью цикла for. Для каждого адреса вызываем функцию withdraw, передавая ей в качестве аргумента адрес получателя. Перед этим мы убираем из адреса лишние пробелы и символы новой строки (\n) с помощью метода strip(), чтобы убедиться, что передаем только саму строку адреса без ненужных символов.

for recipient in recipients:
    withdraw(recipient.strip())

modules/okx.py

Теперь перейдем к самой сложной части — разберем логику взаимодействия с API OKX для вывода средств на кошелек. Дальше будут термины, которые могут быть не совсем понятны, но не переживай, мы все подробно объясним в пояснении.

Этот модуль отвечает за выполнение перевода средств через API OKX. В функции withdraw() мы формируем HTTP-запрос с нужными параметрами для перевода. Важным моментом является рандомизация суммы перевода из диапазона, который мы указали в конфигурационном файле.

Каждый запрос к API требует подписи для безопасности, поэтому мы используем алгоритм HMAC для генерации подписи (как того требует OKX API), которая затем будет добавлена в заголовки запроса.

Функция withdraw():

Вычисляет случайную сумму для перевода.
Формирует тело запроса с нужными параметрами: валютой, суммой, сетью, адресом получателя и другими данными.
Подписывает запрос с помощью вспомогательной функции sign_request().
Отправляет запрос на сервер API OKX и выводит сообщение об успешности перевода.

import json
import random
import requests
from settings import (
    OKX_API_KEY,
    OKX_API_PASSPHRASE,
    TRANSFER_AMOUNT_RANGE,
    TRANSFER_CHAIN,
    TRANSFER_CURRENCY,
)
from utils import sign_request

OKX_BASE_API_URL = "https://www.okx.com"  # базовый URL для запросов к API OKX

def withdraw(recipient: str):
    method = "POST"
    request_path = "/api/v5/asset/withdrawal"

    amount_to_transfer = random.uniform(
        TRANSFER_AMOUNT_RANGE[0], TRANSFER_AMOUNT_RANGE[1]
    )

    body = {
        "ccy": TRANSFER_CURRENCY,
        "amt": str(amount_to_transfer),
        "dest": "4",  # 4 - кошелек, 3 - биржа
        "chain": f"{TRANSFER_CURRENCY}-{TRANSFER_CHAIN}",
        "toAddr": recipient,
        "walletType": "private",
    }

    timestamp, base64_signature = sign_request(
        method=method, request_path=request_path, body=json.dumps(body)
    )

    headers = {
        "OK-ACCESS-KEY": OKX_API_KEY,
        "OK-ACCESS-SIGN": base64_signature,
        "OK-ACCESS-PASSPHRASE": OKX_API_PASSPHRASE,
        "OK-ACCESS-TIMESTAMP": timestamp,
    }

    response = requests.request(
        method=method,
        url=OKX_BASE_API_URL + request_path,
        headers=headers,
        json=body,
    )

    response_data = response.json()

    if response_data.get("code", "") == "0":
        print(
            f"Инициировал перевод | {amount_to_transfer} {TRANSFER_CURRENCY} | {recipient}"
        )
    else:
        print(f"Не удалось инициировать перевод | {response_data.get('msg', 'No message provided')}")

    return response_data

Пояснение:

На данном этапе у тебя, вероятно, возникло множество вопросов, так что давай разберемся по порядку.

Откуда мы знаем, куда и как обращаться к OKX API?

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

Что такое HTTP?

HTTP — протокол, который используется для обмена данными в интернете. Когда мы отправляем запрос к серверу, мы зачастую используем HTTP, чтобы попросить сервер выполнить какую-то задачу, например, вывести средства на кошелек. Существуют и другие протоколы общения в сети, но сегодня не об этом.

Что такое HMAC и зачем нужно подписывать запросы?

Для безопасности. Подпись запроса помогает убедиться, что никто не подменил данные, которые ты отправляешь на сервер. Без подписи кто-то мог бы изменить твой запрос и, например, перевести деньги на свой кошелек. Подпись защищает от этого.
Требование API OKX. OKX требует, чтобы все запросы были подписаны. Если запрос не подписан, API просто отклонит его. В документации OKX подробно объясняется, как правильно подписывать запросы, чтобы сервер принял их.

HMAC — метод, с помощью которого мы создаем подпись для наших запросов. Он использует специальный секретный ключ и алгоритм, который помогает создать уникальную "отпечаток" данных запроса, чтобы сервер знал, что запрос действительно пришел от тебя и не был изменен.

Пояснение к коду:

1. Импорт необходимых библиотек и настроек:

Мы импортируем стандартные библиотеки json, random и requests для работы с JSON-данными, генерации случайных чисел и отправки HTTP-запросов, соответственно. Также импортируем несколько настроек из файла settings.py, таких как ключи для API, диапазон сумм для перевода, сеть и валюту. И из файла utils.py импортируется функция sign_request, которая используется для создания подписи запроса.

import json
import random
import requests
from settings import (
    OKX_API_KEY,
    OKX_API_PASSPHRASE,
    TRANSFER_AMOUNT_RANGE,
    TRANSFER_CHAIN,
    TRANSFER_CURRENCY,
)
from utils import sign_request

2. Базовый URL для запросов к API OKX:

Здесь определяется базовый URL, по которому будут отправляться запросы к API биржи OKX. Если проще, то просто указываем домен OKX вместе с https схемой.

OKX_BASE_API_URL = "https://www.okx.com"

3. Определение функции withdraw:

Функция withdraw принимает один аргумент — recipient, который представляет собой адрес получателя перевода. Мы его передаем из modules/transfer.py, если вдруг ты забыл.

def withdraw(recipient: str):

4. Подготовка запроса:

method = "POST"
request_path = "/api/v5/asset/withdrawal"

Устанавливаем метод HTTP запроса (POST) и путь к API-методу для вывода средств. Мы пишем именно такие значение, так как в документации OKX API по выводу средств указан именно такое метод и данный request_path

5. Генерация случайной суммы для перевода:

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

amount_to_transfer = random.uniform(
    TRANSFER_AMOUNT_RANGE[0], TRANSFER_AMOUNT_RANGE[1]
)

6. Создание тела запроса:

Формируем словарь body, который будет передан в запросе. Здесь мы указываем валюту перевода, сумму, тип назначения (кошелек или биржа), сеть и адрес получателя.

Ты можешь заметить, что "dest" может быть как 4, так и 3. Если бы мы хотели провести внутрибиржевый перевод, то нам понадобилось указать тут цифру 3 и вместа адреса указать email или другой индификатор OKX аккаунта.

body = {
    "ccy": TRANSFER_CURRENCY,
    "amt": str(amount_to_transfer),
    "dest": "4",  # 4 - кошелек, 3 - биржа
    "chain": f"{TRANSFER_CURRENCY}-{TRANSFER_CHAIN}",
    "toAddr": recipient,
    "walletType": "private",
}

7. Создание подписи запроса:

Для безопасности запросов к API необходимо подписывать их. Мы используем функцию sign_request (напишем её позже) для создания подписи. Она возвращает timestamp и signature.

timestamp, base64_signature = sign_request(
    method=method, request_path=request_path, body=json.dumps(body)
)

8. Подготовка заголовков для запроса:

Здесь мы формируем заголовки для HTTP-запроса, включая ключ API, подпись, passphrase и метку времени.

headers = {
    "OK-ACCESS-KEY": OKX_API_KEY,
    "OK-ACCESS-SIGN": base64_signature,
    "OK-ACCESS-PASSPHRASE": OKX_API_PASSPHRASE,
    "OK-ACCESS-TIMESTAMP": timestamp,
}

9. Отправка запроса:

Мы отправляем HTTP-запрос с помощью библиотеки requests, передавая метод, сформированный URL, заголовки и тело запроса.

response = requests.request(
    method=method,
    url=OKX_BASE_API_URL + request_path,
    headers=headers,
    json=body,
)

10. Обработка ответа:

Полученный ответ от OKX API парсим как JSON.

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

Далее проверяем ответ:

Если в ответе код "0", это означает, что перевод был успешно инициирован, и мы выводим сообщение с информацией о переводе. В противном случае выводим сообщение об ошибке.

Спросишь как мы узнали, что будет в ответе? Тут есть два варианта:

Выполнить запрос и запринтить сообщение
Подглядеть в документацию OKX API.

response_data = response.json()
if response_data.get("code", "") == "0":
    print(
        f"Инициировал перевод | {amount_to_transfer} {TRANSFER_CURRENCY} | {recipient}"
    )
else:
    print(f"Не удалось инициировать перевод | {response_data.get('msg', 'No message provided')}")

11. Возврат результата:

Функция возвращает полученные данные ответа от API, чтобы мы могли использовать их дальше, если это необходимо. В нашем случае ответ вернется обратно в modules/transfer.py

return response_data

utils.py

Здесь мы распишем различные вспомогательные функции, такие как подпись запроса к OKX API или получение timestamp.

import hmac
from base64 import b64encode
from datetime import datetime, timezone
from typing import Tuple
from settings import OKX_API_SECRET

def sign_request(method: str, request_path: str, body: str = "") -> Tuple[str, str]:
    timestamp = get_iso_timestamp()
    message = timestamp + method + request_path + body
    signature = hmac.new(OKX_API_SECRET.encode(), message.encode(), "SHA256").digest()
    base64_signature = b64encode(signature).decode()

    return timestamp, base64_signature

def get_iso_timestamp() -> str:
    utc_timestamp = datetime.now(timezone.utc).isoformat(timespec="milliseconds")
    utc_timestamp = utc_timestamp.replace("+00:00", "Z")
    return utc_timestamp

Пояснение к коду:

1. Импорт необходимых библиотек:

Импортируем необходимые библиотеки: hmac для создания подписи к запросу для вывода, b64encode для кодирования подписи в формат base64, как того требует OKX API, datetime и timezone для работы с текущим временем в UTC, а также Tuple для аннотирования типов возвращаемых значений функции. Кроме того, из файла settings загружается секретный ключ API — OKX_API_SECRET, который используется для генерации подписи.

import hmac
from base64 import b64encode
from datetime import datetime, timezone
from typing import Tuple
from settings import OKX_API_SECRET

2. Функция sign_request:

Функция sign_request используется для создания подписи запроса к API OKX. Она принимает три аргумента: HTTP-метод запроса (method), путь запроса (request_path) и тело запроса (body), которое по умолчанию пустое.

def sign_request(method: str, request_path: str, body: str = "") -> Tuple[str, str]:

3. Получение timestamp:

Мы вызываем функцию get_iso_timestamp, чтобы получить метку времени в формате ISO и записать ответ в переменнюу timestamp.

timestamp = get_iso_timestamp()

4. Формирование сообщения для подписи:

Для создания подписи мы формируем строку сообщения, которое включает в себя:

Метку времени (timestamp).
HTTP-метод запроса (method).
Путь запроса (request_path).
Тело запроса (body), которое может быть пустым.

Это также расписано в документации OKX API

message = timestamp + method + request_path + body

5. Создание подписи с помощью HMAC:

Мы используем алгоритм HMAC с SHA256 для создания хэш-значения подписи. Хэш создается с использованием секретного ключа API (OKX_API_SECRET) и строки message, которую мы сформировали ранее.

Для обеих переменных — OKX_API_SECRET и message — применяется метод encode(). Это преобразует их из строкового представления в байтовое, так как функция hmac.new() требует, чтобы входные данные были в виде байтов.

Затем создается объект HMAC с использованием метода hmac.new(), где передаются:

Секретный ключ (OKX_API_SECRET.encode()),
Сообщение (message.encode()),
Алгоритм хэширования ("SHA256").

Метод .digest() возвращает итоговое хэш-значение подписи в виде байтов. Это значение используется для аутентификации запросов к API.

signature = hmac.new(OKX_API_SECRET.encode(), message.encode(), "SHA256").digest()

6. Конвертация подписи в формат base64

После того как мы подписали наш запрос, мы конвертируем это в формат base64 для передачи в заголовках HTTP-запроса.

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

base64_signature = b64encode(signature).decode()

7. Возврат timestamp и подписи

Функция возвращает два значения: временную метку и подпись в формате base64.

return timestamp, base64_signature

8. Определение функции get_iso_timestamp

Эта функция получает текущее время в формате ISO 8601. Мы используем datetime.now(timezone.utc) для получения текущего времени в UTC. Затем, с помощью метода isoformat(timespec="milliseconds"), мы получаем строку с точностью до миллисекунд. В конце заменяем строку "+00:00" на "Z", чтобы привести метку времени к стандарту ISO 8601, который используется в OKX API.

def get_iso_timestamp() -> str:
    utc_timestamp = datetime.now(timezone.utc).isoformat(timespec="milliseconds")
    utc_timestamp = utc_timestamp.replace("+00:00", "Z")
    return utc_timestamp

Подготовка и запуск скрипта

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

1. Создаем виртуальное окружение.

python -m venv .venv

Далее нам нужно активировать его

.venv\Scripts\activate

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

2. Устанавливаем необходимые зависимости

Мы использовали в основном стандартные Python библиотеки, правда одна одна сторонняя все же есть. Это requests, она используется для выполнения HTTP запросов, давай её установим.

pip install requests

3. Указываем адреса в recipients.txt

Тут все просто, берем и вставляем наши адреса кошельков в recipients.txt. Каждый кошелек должен быть на новой строке.

4. Запускаем

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

python main.py

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

Как можно улучшить скрипт

Мы с тобой написали лишь базовый функционал, который можно расширять. Например, ты можешь добавить проверку баланса на OKX перед переводом средств или добавить ожидания выполнения транзакции.

Небольшие наводки, если вдруг тебе станет это интересно:

Для проверки баланса можешь использовать эту ручку.
Если ты захотел добавить ожидание тразакции, то тебе понадобится вытащить из ответа Withdrawal ID (хранится в data["wdId"]) и затем использовать эту ручку.

Заключение

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

Если статья тебе понравилась, сохрани её 📋, чтобы не потерять.

Не забудь написать в комментариях 👇, что именно ты хотел бы увидеть в следующий раз!

AIO Study | Site

Гайд на написание первого скрипта для самых маленьких 👶

2025-01-05T12:33:39.602Z

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

Чему ты научишься? 🧠

1. Установишь интерпретатор Python.

Интерпретатор — это программа, которая читает и выполняет твой код. Без неё твой скрипт просто текст.

2. Установишь и настроишь редактор кода.

Редактор кода - Это место, где ты будешь писать и тестировать свои скрипты.

3. Научишься работать с RPC.

RPC — это способ общения с нодой Ethereum для отправки запросов, например, на создание транзакции или проверку баланса.

Нода Ethereum — это компьютер, который помогает сети Ethereum работать, проверяя и сохраняя все данные о переводах и смарт-контрактах.

4. Напишешь и запустишь скрипт, который запрашивает баланс твоего EVM-кошелька в сети Ethereum.

Сэтапим наше окружение для работы с кодом

Шаг 1. Устанавливаем Python 🐍💻

1. Перейди на сайт и скачай последнюю версию Python.

2. Запусти установщик и поставь галочку на "Add Python to PATH" и "Use admin privileges when installing py.exe", далее чтобы установить нажми на "Install Now" (потребует права администратора, соглашаемся).

Шаг 2. Устанавливаем редактор кода 🖊️🖥️

Для написания кода нужен текстовый редактор. Рекомендуем ~~Блокнот~~ Visual Studio Code (VS Code) так как он стал базой для написания кода.

1. Скачай Visual Studio Code с официального сайта

2. Запусти установщик и следуй инструкциям. Можно отметить "Create desktop shortcut", если хочешь ярлык на рабочем столе.

3. Установи расширение "Python" для удобной работы. В VS Code слева, в меню, выбери иконку с кубами и в поиске введи "Python". Найди и установи это расширение.

Приступаем к ворку над скриптом

Шаг 1. Прорабатываем действия перед написанием кода 🤔

Составим план написания скрипта, для примера возьмем чекер баланса EVM-кошелька в сети Ethereum. Составить план ты можешь с ChatGPT или немного погуглив. Просто задаешь запрос по типу "Как получить баланс EVM-кошелька в сети Ethereum".

Кстати, умение гуглить это еще одна база для каждого кодера 😎

Вот что у нас вышло:

1. Подключиться к Ethereum-ноде через RPC.
2. Указать адрес кошелька.
3. Получить баланс кошелька в Wei и преобразовать его в ETH.

Wei — это наименьшая единица эфира, 1 ETH = 10^18 Wei.

4. Вывести результат в удобном формате.

Шаг 2. Приступаем к написанию кода 👨‍💻

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

Теперь, когда всё готово, перейдём к написанию и запуску скрипта. Написать его ты можешь вместе с ChatGPT (придерживайся памятки выше!).

1. Создай папку с осмысленным названием

2. Открой её через ПКМ → "Open with Code" в VS Code

3. Слева создай файл main.py

4. Создай и активируй виртуальное окружение:

Виртуальное окружение - изолированная среда Python, чтобы зависимости не мешали друг другу.

Для создания виртуального окружение открой терминал (Ctrl + `) и введи:

python -m venv .venv

Каждый раз после перезапуска терминала или если не видно (.venv) слева, вводи команду ниже, чтобы активировать виртуальное окружение. Без нее будет использоваться глобальное окружение.

Пример надписи (.venv) перед приглашением терминала

Для активации созданного .venv открой терминал (Ctrl + `) и введи:

.venv\Scripts\activate

5. Установи зависимости:

Открой терминал и введи:

pip install web3

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

6. Теперь открой ранее созданный main.py и вставь написанный код:

from web3 import Web3

# URL RPC для подключения к Ethereum-ноде
rpc_url = "https://eth.llamarpc.com"  # можно взять публичный RPC на https://chainlist.org/
web3 = Web3(Web3.HTTPProvider(rpc_url))

# Проверяем подключение
if web3.is_connected():
    print("Подключение к Ethereum-ноде успешно!")
else:
    print("Ошибка подключения к Ethereum-ноде.")
    exit()

# Адрес кошелька
wallet_address = web3.to_checksum_address("0xYOUR_EVM_ADDRESS")  # изменяем на свой адрес

# Получаем баланс в Wei
balance_wei = web3.eth.get_balance(wallet_address)

# Переводим баланс в ETH
balance_eth = web3.from_wei(balance_wei, 'ether')

print(f"Баланс кошелька {wallet_address}: {balance_eth} ETH")

В этом примере тебе нужно заменить в данной строке фейк адрес на свой

wallet_address = web3.to_checksum_address("0xYOUR_EVM_ADDRESS")

А также, если ты хочешь, то можешь заменить RPC. Найти публичные RPC ты можешь тут

rpc_url = "https://eth.llamarpc.com"

Шаг 3. Запуск скрипта ▶️💻

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

python main.py

Если все правильно, то у тебя будет сообщение в терминале с твоим балансом ✔️

Пример вывода в терминал при успешном выполнении

Домашка:
Попробуй сделать так, чтобы скрипт получал баланс не одного кошелька, а сразу нескольких.

Подсказка:
Для этого ты можешь использовать циклы и списки/файл.

AIO Study | Site

🔥 Cursor Editor: ваш новый лучший друг в кодинге 🖥️

2024-12-08T20:13:06.214Z

Вы когда-нибудь мечтали писать код быстрее и с меньшим количеством ошибок? 😏 Тогда познакомьтесь с Cursor Editor — инструментом, который реально прокачает вашу разработку! 🚀

Что такое Cursor Editor?

Это не просто очередной редактор кода. Cursor — ваш персональный помощник, основанный на AI (да-да, тот самый GPT-4 и другие последние модели). Он не просто подсказывает, что написать дальше, а помогает думать над кодом, генерируя фрагменты и предлагая решения. 🎯

Почему Cursor — это круто?

• Экономия времени: Забудьте о рутинных задачах. Cursor может сгенерировать код по вашему описанию. Просто опишите, что нужно, и вуаля! ✨

Использование функции "Chat" и "Composer", которые позволяют генерировать код по описанию.

• Меньше багов: Благодаря умным подсказкам, вы реже делаете опечатки и логические ошибки. Код становится чище и стабильнее. 🧹

"Fix with AI" позволяет исправить ошибку/баг с помощью ИИ, экономя вам не один десяток минут на поиск корня проблемы и решения ее самостоятельно.

• Быстрое прототипирование: Хотите проверить идею? Cursor поможет накидать рабочий прототип полностью готового и рабочего продукта за считанные часы. ⏱️

• Освоение новых технологий: Нет времени разбираться с новым фреймворком? Cursor подскажет, как начать. 📚

💼 Реальные примеры использования:

Пример 1:

@Tristan0x поделился в своем твите, как Cursor Editor (в связке с другими AI инструментами) помог ему разработать DEX биржу без каких-либо знаний в fornt-end "за 1 день".

“Сегодня днем мне удалось создать полноценный интерфейс биржи на @nextjs практически без опыта работы с фронтендом, используя сочетание cursor_ai + Claude + v0. Он даже поддерживает кошельки solana без костылей и получает данные RPC через наш собственный SDK.”

Пример 2:

Другой пользователь, @AlexFinnX, рассказал в своем твите, как Cursor Editor помог ему быстро реализовать аналог старого доброго Марио ‼️ БЕЗ КАКОГО ЛИБО ОПЫТА В КОДИНГЕ ‼️.

“Я создал полноценную игру в стиле Mario, используя всего лишь СКРИНШОТ с помощью ИИ. Я загрузил скриншот в Cursor, попросил сделать мне такую игру — и он это сделал. Посмотрите, как это происходило, в видео ниже. Теперь буквально каждый может превращать свои идеи в игры и приложения.”

‼️ Но есть нюанс…

Важно понимать, что использование таких инструментов во время обучения (например, на AIO Study) может сыграть злую шутку. 🤔

❓ Почему не стоит использовать AI во время обучения:

• Глубокое понимание: Если за вас пишет код AI, можно упустить важные концепции и нюансы языка.

• Навык решения проблем: Самостоятельное решение задач укрепляет навыки и развивает мышление.

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

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

Когда Cursor реально спасает

• Сжатые сроки: Когда дедлайн уже завтра, а работы — непочатый край. 😅

• Прототипирование: Быстро накидать идею и посмотреть, как она работает.

• Исследование новых идей: Хотите попробовать что-то новое без глубокого погружения? Cursor поможет стартовать.

💡Несколько лайфхаков по использованию Cursor

• Описание задач на естественном языке: Просто пишите, что вам нужно, обычными словами, и Cursor преобразует это в код.

• Исправление ошибок: Если что-то не работает, попросите Cursor найти и исправить ошибку.

• Оптимизация кода: Хотите сделать код быстрее или чище? Cursor даст советы по улучшению.

🤓 Заключение

Cursor Editor — мощный инструмент, который может значительно облегчить жизнь разработчика. Но, как и с любым инструментом, важно использовать его с умом. 🧠

🔥 Хотите сами стать профи и писать код легко и быстро даже без помощи ИИ ?

Присоединяйтесь к нашему курсу «Python для Web3-разработки» и получите глубокие знания и практические навыки! 🚀

👉 Присоединиться к каналу

👉 Узнать больше о курсе

AIO Study

Гайд по нейросетям

Оглавление

Кастомные инструкции

Как получить ответ, который тебе нужен

Разберём на примере: с чего ты можешь начать диалог?

База данных ChatGPT

Как эффективно использовать ChatGPT как базу данных

Упрощение жизни

Сравнение ChatGPT и Google в различных задачах

Какую нейронку и для чего юзать

Заключение

Как наш ученик заработал $50,000 на тестнете Berachain

Кейс, который случился прямо вот только что. И еще раз доказывает – на любом рынке можно зарабатывать.

При продаже токенов по цене от $8 до $12 за штуку он заработал около $50,000 на тестнете, не вложив ни копейки.

Что дальше?

Гайд на Chrome профиля

Оглавление

Создание профиля

Настройка профиля

Синхронизация

Сохранение данных

Приватность

Startup

Расширения

Trace

SwitchyOmega

Разбор парсера Solana, EVM щитков

Что делает наш парсер?

Что ты должен уметь?

Где посмотреть код скрипта?

Оглавление

Что такое классы

Функции НЕ хуже классов

Смотрим на структуру скрипта

Приступаем к разбору кода

settings.py

main.py

utils.py

modules/parser.py

modules/telegram.py

modules/tweet_id_storage.py

modules/x.py

Заключение

Пишем софт по раскидыванию баланса с биржи

Оглавление

Что такое API

Получаем ключи для взаимодействия с OKX API

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

Начинаем писать код

settings.py

main.py

modules/transfer.py

modules/okx.py

utils.py

Подготовка и запуск скрипта

Как можно улучшить скрипт

Заключение

Гайд на написание первого скрипта для самых маленьких 👶

Оглавление

Чему ты научишься? 🧠

Сэтапим наше окружение для работы с кодом

Шаг 1. Устанавливаем Python 🐍💻

Шаг 2. Устанавливаем редактор кода 🖊️🖥️

Приступаем к ворку над скриптом

Шаг 1. Прорабатываем действия перед написанием кода 🤔

Шаг 2. Приступаем к написанию кода 👨‍💻

Шаг 3. Запуск скрипта ▶️💻

🔥 Cursor Editor: ваш новый лучший друг в кодинге 🖥️