DEV Community: Maksym Zavalniuk

StudyHelper - my new pet project(Telegram bot)

Maksym Zavalniuk — Sun, 29 Sep 2024 12:49:08 +0000

Preface

Hello everyone!🙂
This is my new Telegram bot and I want to share this project with you. You can get all the available code here.

The idea of the bot is to make the learning process easier. Teachers create subjects and tasks, invite students, grade them, and get statistics. Students receive a list of tasks that are closest to the due date, create solutions, and upload them.

Since this is a pet project, you won't see any grandiose things here. Mostly, I wanted to get acquainted with new technologies, such as Tortoise and AWS.
You can see the most interesting solutions and features of the bot below⬇️

Features

Teachers

The main thing that a teacher can do is create subjects, invite students to them, and interact with them.

As you can see, all the functionality here is done not through buttons, but through links. These are deep links. That is, in the chat, you will see something like “/start”, but in reality, it will be “https://t.me/testmezgoodlebot?start=eyJrZXkiOiAic2VlX3Rhc2tzIiwgImlkIjogNH0”. And this code will process it. I made it so that it launches some methods from utils using this method. And accordingly, it was enough for me to create a method, pass the name, and it's done. Very convenient.
So, if we continue, teachers can look at the assignments for the subject like this:

and statistics, for example, how many solutions from students there are in percentage value and the histogram of grades through the subject.

When we open solutions to tasks, we can evaluate them through the buttons, and the message will be updated on the spot. There will also be a link to the work file. All data is stored on AWS S3.

The entire logic of interaction with AWS S3 can be found here. It is the same for both students and teachers.

Students

This is what the start of work looks like for a student (I've already skipped the process of joining the course).

That's how I created a new solution. At first, I wanted to add it to the task, but the deadline had already passed. Since I am both a teacher and a student, I received a notification that the student had uploaded the solution.

On AWS, the bucket looks like this: subfolders for subjects and students, and then the file itself is created here.

Students can also use the feedback function with the teacher (code here). All of this is built on states.

Noteworthy

I may not have shown the most important features, but I will provide a list of what might be of interest:

Using a filter that, in addition to passing to the handler, also returns the value of the object from the database.
Using the magic filter F.
Creating charts with seaborn.
Using ORM Tortoise.
Pushing objects to handlers using middlewares.
Send notifications on a schedule.

Conclusion

I hope you enjoyed my pet project and learned something new. Write your impressions and questions in the comments. By the way, soon in the future, I want to launch my course, where I will go through all the topics of developing Telegram bots, as well as using artificial intelligence.

Top VS Code Extensions to Boost Your Productivity

Maksym Zavalniuk — Fri, 16 Aug 2024 17:02:51 +0000

Introduction

Visual Studio Code (VS Code) is a versatile and powerful code editor that has taken the developer community by storm. One of its standout features is the ability to customize and extend its capabilities through extensions. These extensions can enhance your productivity, streamline your workflow, and make coding a more enjoyable experience. There are already a lot of posts about the most popular extensions, but I want to highlight the ones that are most useful to me!

Prettier - Code Formatter

When working on code, consistency, and readability are key factors that can make or break a project. Manually formatting code can be time-consuming and prone to errors. That's where Prettier comes in.

Prettier is an opinionated code formatter that enforces a consistent style by parsing your code and reprinting it with its own rules. It takes the hassle out of formatting by ensuring that your code looks the same no matter who wrote it.

Why Use Prettier?

Consistency Across the Team: Prettier ensures that everyone on your team writes code in the same style. This is especially useful in collaborative projects where multiple developers work on the same codebase.
Time-saving: With Prettier, you no longer need to worry about manually adjusting your code's format. A quick save and your code is perfectly formatted according to the project's rules.
Error Reduction: Prettier eliminates debates about code style during code reviews, allowing the team to focus on logic and functionality instead of formatting.
Supports Multiple Languages: Prettier isn't just for JavaScript; it supports many languages like TypeScript, CSS, HTML, JSON, and more.

Prettier is an investment in your productivity and coding satisfaction. Give it a try, and you'll never want to format code again manually.

GitLens — Git supercharged

Git is an essential tool for version control, but managing and understanding Git's history can sometimes be challenging. GitLens, a powerful Visual Studio Code extension, enhances your Git experience by providing rich insights and tools right within your editor.

GitLens supercharges the Git capabilities built into Visual Studio Code. It helps you visualize code authorship, navigate through code changes, and gain a deeper understanding of your repository history. Whether you're tracking changes, investigating who made specific modifications, or analyzing commit history, GitLens brings the power of Git directly to your fingertips.

Why Use GitLens?

Code Blame Annotations: GitLens provides inline blame annotations, allowing you to see who last modified a line of code and when. This is incredibly useful for understanding the context behind changes.
Commit Details at a Glance: Hover over a line of code to see detailed commit information, including the author, commit message, and timestamp, all without leaving your editor.
File and Line History: GitLens makes it easy to explore the history of a file or even a specific line of code. This helps you trace the evolution of your code and understand how it got to its current state.
Compare Revisions: Quickly compare the current file with previous versions, side by side, to see what has changed. You can also compare branches, tags, or commits to understand the differences.
Explore Repositories: GitLens provides a powerful repository view that lets you explore branches, tags, remotes, stashes, and more, all within Visual Studio Code.
Interactive Rebase Editor: Manage your commits easily using the interactive rebase editor. GitLens makes it simpler to reorder, squash, or edit commits during a rebase.
Rich Customization: Tailor GitLens to your workflow with extensive customization options, from altering the appearance of annotations to configuring how information is displayed.

GitLens is an indispensable extension for anyone working with Git in Visual Studio Code. It provides a wealth of information right at your fingertips, making it easier to understand your codebase's history and collaborate with others.

WakaTime

Ever wondered how much time you spend coding? Understanding your coding habits can help you become more productive and manage your time better. WakaTime, a powerful time-tracking extension for Visual Studio Code, provides detailed insights into your coding activities.

WakaTime is an open-source time-tracking tool that automatically records how much time you spend on different programming tasks. It integrates seamlessly with Visual Studio Code, providing real-time analytics on your coding activities. WakaTime tracks which projects you're working on, how much time you spend on each file, and even which languages you use the most.

Why Use WakaTime?

Automatic Time Tracking: WakaTime runs in the background and automatically tracks your coding time without any manual input. Simply install it, and it starts collecting data.
Detailed Insights: Get a breakdown of your coding habits, including time spent on specific projects, files, and programming languages. This data is invaluable for understanding how you allocate your time.
Goal Setting: Set personal goals for your coding time, such as spending a certain number of hours on a project each week. WakaTime helps you stay on track by monitoring your progress.
Improved Productivity: By analyzing your coding patterns, you can identify productivity peaks and dips, allowing you to optimize your work schedule.
Team Collaboration: WakaTime also offers team features, enabling you to see how much time each team member spends on a project, which can be useful for project management.
Integrations: WakaTime integrates with many other tools and editors, so you can track your coding time across different platforms, not just in Visual Studio Code.

WakaTime is more than just a time tracker; it's a tool for self-improvement. By gaining insights into how you spend your coding time, you can make data-driven decisions to enhance your productivity and achieve your goals.

GitHub Pull Requests

Managing pull requests (PRs) can be time-consuming, especially when switching between your code editor and GitHub. The GitHub Pull Requests extension for Visual Studio Code simplifies this process by allowing you to create, review, and manage pull requests directly within your editor.

The GitHub Pull Requests extension integrates GitHub's pull request functionality into Visual Studio Code. It enables you to manage pull requests without leaving your editor, making it easier to collaborate, review code, and merge changes. Whether you're working on open-source projects or collaborating with your team, this extension brings the power of GitHub to your fingertips.

Why Use GitHub Pull Requests?

Integrated Workflow: Manage your pull requests directly in Visual Studio Code, reducing context switching and increasing productivity.
Effortless Code Reviews: Review code changes, leave comments, and approve or request changes on pull requests without leaving your development environment.
Real-Time Collaboration: See real-time updates on pull requests, including comments, reviews, and merge conflicts, right in your editor.
Create and Manage PRs: Easily create new pull requests, assign reviewers, and track the status of your PRs from within Visual Studio Code.
Enhanced GitHub Integration: The extension also integrates with GitHub Issues, enabling you to link issues to pull requests and track their progress.

The GitHub Pull Requests extension is a game-changer for developers who work with GitHub. Integrating pull request management into Visual Studio Code saves time, reduces context switching, and enhances collaboration.

Conclusion

Visual Studio Code becomes an even more powerful tool with extensions like Prettier, GitLens, WakaTime, and GitHub Pull Requests. These extensions not only enhance your productivity but also make the coding process more organized, efficient, and enjoyable. Whether you're working solo or as part of a team, these tools will help you get the most out of your VS Code experience. If you’re not using these extensions yet, I highly recommend giving them a try and seeing the benefits for yourself.

Physics into programming: Using physical phenomena to cluster data

Maksym Zavalniuk — Tue, 18 Jun 2024 06:14:47 +0000

Introduction

This post will explore the intersection of physics and programming, specifically how physical phenomena can be used to cluster data. A teacher from my university suggested implementing an interesting method. Our new clustering method, called Surface Tension Clustering, aims to address some limitations of existing clustering algorithms by leveraging the physical analogy of surface tension observed in liquids. This method identifies cluster boundary points based on the imbalance of attractive forces, similar to how surface tension acts on molecules at the surface of a liquid.

But let's first talk about what clustering is and what methods exist.

General Information on Clustering

Clustering is an unsupervised learning method, meaning it does not rely on pre-labeled data to train a model. The main goal is to find natural groupings within the data. There are several main approaches to clustering:

Centroid-based methods: Clusters are represented by a central point (centroid). Example: K-means clustering.
Hierarchical methods: Clusters are formed into a hierarchy, either by merging smaller clusters into larger ones (agglomerative) or splitting larger clusters into smaller ones (divisive).
Density-based methods: Clusters are defined as dense regions in the data space. Example: DBSCAN.

Popular Clustering Methods

K-means Clustering

K-means is one of the most widely used clustering algorithms. It partitions data into K clusters, where each data point belongs to the cluster with the nearest mean. Here’s a simple implementation in Python:

from sklearn.cluster import KMeans
import numpy as np

# Sample data
X = np.array([[1, 2], [1, 4], [1, 0], [4, 2], [4, 4], [4, 0]])

# Create KMeans instance with 2 clusters
kmeans = KMeans(n_clusters=2, random_state=0).fit(X)

# Get cluster centers
centers = kmeans.cluster_centers_

# Predict the cluster for new samples
predictions = kmeans.predict([[0, 0], [4, 4]])

Mean Shift Clustering

Mean shift is a sliding-window-based algorithm that attempts to find dense areas of data points. It automatically determines the number of clusters.

DBSCAN (Density-Based Spatial Clustering of Applications with Noise)

DBSCAN is a density-based clustering algorithm that groups together points that are closely packed together, marking points that lie alone in low-density regions as outliers.

from sklearn.cluster import DBSCAN

# Sample data
X = np.array([[1, 2], [1, 4], [1, 0], [4, 2], [4, 4], [4, 0]])

# Create DBSCAN instance
dbscan = DBSCAN(eps=1, min_samples=2).fit(X)

# Get labels
labels = dbscan.labels_

Gaussian Mixture Models (GMM)

GMM is a probabilistic model that assumes all data points are generated from a mixture of several Gaussian distributions with unknown parameters.

from sklearn.mixture import GaussianMixture

# Sample data
X = np.array([[1, 2], [1, 4], [1, 0], [4, 2], [4, 4], [4, 0]])

# Create GMM instance
gmm = GaussianMixture(n_components=2).fit(X)

# Predict cluster for new samples
predictions = gmm.predict([[0, 0], [4, 4]])

Hierarchical Clustering

Hierarchical clustering builds a hierarchy of clusters either by merging smaller clusters into larger ones (agglomerative) or splitting larger clusters into smaller ones (divisive).

Introducing New Clustering Method: Surface Tension Clustering

Concept and Algorithm

The Surface Tension Clustering method is inspired by the behavior of molecules in liquids, where surface molecules experience an inward force due to the lack of neighboring molecules above them. In this analogy, boundary points of clusters are determined by the imbalance of vector forces from surrounding points.

Here’s a step-by-step outline of the algorithm:

Distance Calculation: Compute the distances between all pairs of points.
Neighborhood Identification: For each point, identify the nearest neighbors (typically 4-6 points).
Center Calculation: Determine the center of mass for the neighboring points.
Force Calculation: Calculate the resultant force acting on each point. If the force is significant, the point is considered a boundary point.
Cluster Formation: Use the boundary points to form clusters and identify the support points, which are the closest points between different clusters.

How did I improve it?

Before applying the main clustering algorithm, I divide the points into smaller clusters using k-means and then look for the boundary points within them. I also wrote an interface using PyQT, which I will demonstrate below.

Demonstration of the work

So, here you can see the interface of the program, where I have specified random points, and different colours represent different clusters within which the boundary points will be searched. You can also adjust the sensitivity of the algorithm here.

Research can also be carried out in 3D space:

Now I'll show you a more visual example of how the algorithm works. In the picture, you can see that the red dots are the boundary dots, and if you connect them with a line, you can imagine that the grey dots are inside the water drop, i.e. they belong to the same cluster.

Conclusion

Clustering is a powerful tool for uncovering hidden structures in data. Traditional methods like K-means and DBSCAN are widely used, but new Surface Tension Clustering method demonstrates significant advancements in efficiency, adaptability, and scalability. By leveraging the physical analogy of surface tension, we offer a novel approach to clustering that addresses some of the limitations of existing methods. GitHub repository you can see here.

Thank you for reading this far, I'd love to read your thoughts in the comments!

Format repo - GitHub Action to format your code with comfort

Maksym Zavalniuk — Sun, 21 May 2023 17:52:57 +0000

What I built

I made a GitHub action that automatically formats the Python and JavaScript code after each commit and pushes it to the repository.

Category Submission:

DIY Deployments

App Link

App is here.

Screenshots

Description

The action installs black _ and _prettier and uses them to format Python and JavaScript code. After using git commands, changes are pushed to the repository.

Link to Source Code

Code is here.

Permissive License

MIT License

Background (What made you decide to build this particular app? What inspired you?)

First, I wanted to make an action that would automatically push commits to GitLab and BitBucket, like a mirror. But there were difficulties with the API of these services. Then I decided to implement my old idea - an action that automatically formats the code. I tried to do it before with Docker and now with js, and it turned out to be much easier.

How I built it (How did you utilize GitHub Actions or GitHub Codespaces? Did you learn something new along the way? Pick up a new skill?)

I used the libraries from actions/toolkit to create my action. It's more comfortable than when I did it with Docker. I looked at all the libraries, and most of all: actions/core, actions/exec and actions/github.

Additional Resources/Info

To use it, you need to enable workflow read:write in the settings.

I got my first job!

Maksym Zavalniuk — Fri, 19 May 2023 08:41:54 +0000

So, I got my first job as a backend developer. And it seems that this is a great success, for a junior programmer who has no professional experience. What if I told you I quit in two weeks? That's exactly what happened.

How it started?

First, I will tell you how I came across it. About three months ago, I created a resume in the constructor and started sending it to various job search sites. One day, I accidentally noticed in the mail in the "Spam" tab that I received a reply from one vacancy. The vacancy was about backend development. Required skills: Django, DRF, and Docker. Nothing special. In the test task, it was necessary to create a chat API (you can see the code here https://gitlab.com/mezgoodle/test-project). After a successful test task, there was an invitation to a conversation with the team leader, and after that, live coding. The questions were interesting, it's not just what types are in Python. There were enough questions about Django ORM, so I advise you to learn it well. At live coding, there was a task related to working with lists and dictionaries. The main thing was to show your thinking, the way to solve the problem, not necessarily successfully.

I'll skip joining Slack, Jira, and so on.

Start of work

The next stage was the start of work. The first problem that appeared was that my laptop, purchased for training, could not cope with the project, especially with raised containers in Docker. I later fixed this problem, but the first signal was already there.
The first tasks were not difficult at all, because the project manager did very wisely, gradually pouring me into the project.

Difficulty

But what exactly is the problem? Before that, I got used to the fact that when I do a project, everything usually works out and problems are solved by researching on the Internet. Everything is not so easy here. I felt responsible and that I should do everything successfully. And accordingly, when something did not work out, even if it did not concern me, I became very depressed. And so after two weeks, I decided that it was better for me to quit my job.

Make a note of it

So, what are the most important conclusions I want to tell you? If you have your first job, then be prepared that you will not get anything done. And that's normal. No one succeeds immediately. So be persistent. And remember that your health is the most important thing.

What am I doing now?

I started using ClickUp to create a working environment for myself and improve my projects. I cleaned my GitHub and left only the essentials. I started playing chess regularly, solving problems on codewars, and going through two topics from the roadmap.sh a day.

Bot-Moderator for Telegram chats. Administrator actions

Maksym Zavalniuk — Tue, 06 Sep 2022 09:03:08 +0000

What will we do? 😊

In this part, there will be no difficult programming information, but we will look at the functionality of the bots.

Let's write code 🖊️

Yes, we'll jump right into writing the code, namely some important handlers. Because we have already received all the necessary knowledge in previous posts.

So let's open the handlers folder and fill some files:

ban.py

from aiogram.types import Message, ChatType

from datetime import timedelta

from loader import dp


@dp.message_handler(is_admin=True, commands=['ban'], commands_prefix='!/',
                    chat_type=[ChatType.GROUP, ChatType.SUPERGROUP])
async def ban_user(message: Message):
    if not message.reply_to_message:
        await message.reply('This command needs to be as a reply to message')
        return
    await message.delete()

    await message.bot.ban_chat_member(chat_id=message.chat.id, user_id=message.reply_to_message.from_user.id,
                                      until_date=timedelta(seconds=29))
    return await message.reply_to_message.reply('User has been banned')


@dp.message_handler(is_admin=True, commands=['unban'], commands_prefix='!/')
async def unban_user(message: Message):
    if not message.reply_to_message:
        await message.reply('This command needs to be as a reply to message')
        return
    await message.delete()

    await message.bot.unban_chat_member(chat_id=message.chat.id, user_id=message.reply_to_message.from_user.id,
                                        only_if_banned=True)
    username = message.reply_to_message.from_user.username
    return await message.reply_to_message.reply(f'User @{username} has been unbanned')

Let's understand what is written here. In the decorator, we write filters: our own, which command, the prefix to the command, and the type of chat. Next, in the body of the function, we check whether the message is a reply to another. Then the most interesting thing: ban the user with the aiogram method. And here the question may arise: "Why there is a time delta of 29 seconds?". For this, we need to refer to the Telegram API documentation:

Date when the user will be unbanned, unix time. If the user is banned for more than 366 days or less than 30 seconds from the current time they are considered to be banned forever. Applied for supergroups and channels only.

In our case, banning for 29 seconds means banning the user forever.

kick.py

from aiogram.types import Message, ChatType

from loader import dp

from datetime import timedelta


@dp.message_handler(is_admin=True, commands=['kick'], commands_prefix='!/',
                    chat_type=[ChatType.GROUP, ChatType.SUPERGROUP])
async def kick_user(message: Message):
    if not message.reply_to_message:
        return await message.reply('This command needs to be as a reply to message')
    await message.delete()

    user_id = message.reply_to_message.from_user.id
    seconds = 60
    await message.bot.ban_chat_member(chat_id=message.chat.id, user_id=user_id, until_date=timedelta(seconds=seconds))
    return await message.reply_to_message.reply(f'User has been kicked for the {seconds} seconds')

Everything is the same here, but a kick differs from a ban in that the user can return.

mute.py

from aiogram.types import Message, chat_permissions, ChatType

from datetime import timedelta

from loader import dp


@dp.message_handler(is_admin=True, commands=['mute'], commands_prefix='!/',
                    chat_type=[ChatType.GROUP, ChatType.SUPERGROUP])
async def mute_user(message: Message):
    if not message.reply_to_message:
        return await message.reply('This command needs to be as a reply on message')
    await message.delete()

    user_id = message.reply_to_message.from_user.id
    seconds = 30

    await message.bot.restrict_chat_member(chat_id=message.chat.id, user_id=user_id,
                                           until_date=timedelta(seconds=seconds),
                                           permissions=chat_permissions.ChatPermissions(can_send_messages=False,
                                                                                        can_send_polls=False,
                                                                                        can_send_other_messages=False,
                                                                                        can_send_media_messages=False))
    return await message.reply_to_message.reply(f'User has been muted for the {seconds} seconds')


@dp.message_handler(is_admin=True, commands=['unmute'], commands_prefix='!/',
                    chat_type=[ChatType.GROUP, ChatType.SUPERGROUP])
async def unmute_user(message: Message):
    if not message.reply_to_message:
        return await message.reply('This command needs to be as a reply on message')
    await message.delete()

    user_id = message.reply_to_message.from_user.id
    await message.bot.restrict_chat_member(chat_id=message.chat.id, user_id=user_id,
                                           permissions=chat_permissions.ChatPermissions(can_send_messages=True,
                                                                                        can_send_polls=True,
                                                                                        can_send_other_messages=True,
                                                                                        can_send_media_messages=True))
    return await message.reply_to_message.reply('User has been unmuted')

Everything is similar here, the only difference is the method we use.

admins.py

from aiogram.types import Message, ChatType

from loader import dp


@dp.message_handler(commands=['admins'], chat_type=[ChatType.GROUP, ChatType.SUPERGROUP])
async def admins_command(message: Message) -> Message:
    chat_id = message.chat.id
    admins = await message.bot.get_chat_administrators(chat_id)
    text = ''
    for admin in admins:
        text += f'@{admin.user.username} '
    return await message.answer(text, disable_notification=True)

Here we only get a list of group administrators. Any user can call this command.

What's next? ❓

Next, we'll do some check on new chat members and look at the Finite State Machine.

References 🔗

Second part file structure

Thank you for reading! ❤️ ❤️ ❤️

Bot-Moderator for Telegram chats. Filters

Maksym Zavalniuk — Thu, 01 Sep 2022 11:26:01 +0000

What are the filters? 💭

When we register a handler, we specify what command it should respond to, what type of message to accept, etc. For example:

@dp.message_handler(is_admin=True, commands=['kick'], commands_prefix='!/',
                    chat_type=[ChatType.GROUP, ChatType.SUPERGROUP])
async def kick_user(message: Message):

As you can see, here the handler will be executed only when:

this will be the kick command;
the command starts with "!" or "/";
The command is written in a group or supergroup.

These are all called filters. Somewhere deep in the library, handler registration takes place, where its filters are registered for each handler:

def register(self, handler, filters=None, index=None):
        """
        Register callback

        Filters can be awaitable or not.

        :param handler: coroutine
        :param filters: list of filters
        :param index: you can reorder handlers
        """
        from .filters import get_filters_spec

        spec = _get_spec(handler)

        if filters and not isinstance(filters, (list, tuple, set)):
            filters = [filters]
        filters = get_filters_spec(self.dispatcher, filters)

        record = Handler.HandlerObj(handler=handler, spec=spec, filters=filters)
        if index is None:
            self.handlers.append(record)
        else:
            self.handlers.insert(index, record)

If we look at what the handle decorator accepts, we will see the following:

and today we will learn to create a custom filter.

Create your own filters ✍️

First, we need to create a file in the filters folder, for example, admin.py:

📦tgbot
┣ 📂filters
┃ ┣ 📜admin.py
┃ ┗ 📜init.py

and add the following code inside:

from aiogram import types
from aiogram.dispatcher.filters import BoundFilter


class IsAdminFilter(BoundFilter):
    key = 'is_admin'

    def __init__(self, is_admin):
        self.is_admin = is_admin

    async def check(self, message: types.Message) -> bool:
        member = await message.bot.get_chat_member(message.chat.id, message.from_user.id)
        return member.is_chat_admin()

As you can see, the filter is a simple Python class that inherits a BoundFilter class that allows us to create our own filters. We have a field key = 'is_admin' that shows how we will describe our filter in the handlers. In addition to the structure, we have the main method async def check(). You can describe any of your logic inside it, but this method must return a Boolean value (True or False).

Connecting own filters ⛓️

Simply creating a class is not enough. Next, you need to go to the bot.py file, import out filter and bind it to the dispatcher:

...
from tgbot.config import load_config
from tgbot.services.setting_commands import set_default_commands
from tgbot.filters.admin import IsAdminFilter

...

def register_all_filters(dispatcher: Dispatcher) -> None:
    logger.info('Registering filters')
    dispatcher.filters_factory.bind(IsAdminFilter)

Now we can add our filter to the handlers as I showed in the first picture. In this article, we will not yet write handlers for administering chats.

Additional part 😺

For now, let's program the handlers for the two commands: /start and /help:

tgbot/handlers/start.py:

from aiogram.types import Message
from aiogram.dispatcher.filters.builtin import CommandStart

from loader import dp


@dp.message_handler(CommandStart())
async def start_command(message: Message) -> Message:
    return await message.answer('Add a bot to the chat, give the administrator permissions and use it')

tgbot/handlers/help.py:

from aiogram.types import Message
from aiogram.dispatcher.filters.builtin import CommandHelp

from loader import dp


@dp.message_handler(CommandHelp())
async def help_command(message: Message) -> Message:
    """
    This handler will be called when a user sends `/help` command
    """
    return await message.answer("""
User's command:
    /help - get commands
    /admins - get chat admins
    /dice - roll a dice
Administrator's command:
    !kick - kick a user
    !ban - ban a user
    !mute - mute a user
    !unmute, !unban - opposite commands
""")

Here, the decorators have already used filters built into aiogram. The entire list of such filters can be found here.

References 🔗

Second part file structure

Thank you for reading! ❤️ ❤️ ❤️

Bot-Moderator for Telegram chats. Introduction

Maksym Zavalniuk — Fri, 26 Aug 2022 07:14:33 +0000

Overview 😎

Good day everyone! Starting with this post, I'm starting a series of articles on developing a bot-moderator for Telegram chats. During them, we will consider the following topics: filters, state machine, middleware, internationalization. For each article, I will provide a code that you are free to use.

What the bot can do? 💪

By adding it to the chat, you can:

Check whether the user who entered the group is not a robot:

Kick or ban user:

Mute and unmute user:

List of all commands:

How to start writing a bot? 🤔

First of all, I recommend that you read my first two articles in the tutorial series. But don't be disappointed if you don't fully understand them. My articles are suitable for those who have never developed bots. All you need to do is download the files from this repository.

References 🔗

First part file structure

Thank you for reading! ❤️ ❤️ ❤️

Everything should be in order. Telegram bots are no exception

Maksym Zavalniuk — Wed, 17 Aug 2022 06:22:47 +0000

A quick trailer 🤗

The information may be difficult to understand at first, but be patient and read to the last chapter. There will be both the code and the explanation.

Why do we need templates in programming? 🤔

Hello everyone! I think many of you have come across file structure patterns in your projects. This is best seen in web development. For example, when creating apps on React, RubyOnRails or Django:

This is really convenient for several reasons. Your code is organized and everything is in its place (folders). Finding the function that calculates the cube root will be much easier in the folder called "math". If you work in a team, your partner will not wonder where everything is.

The same applies to Telegram bots. Previously, I wrote everything in one file, as it was in the last post (although the config was in a separate file). And everything was fine until my file got too big. Really, look how many lines there are in this file:

439 LINES! At some point, it became difficult to follow, and I started looking for a solution.

Templates for bots really existed! 😮

I found out about it quite by accident. While browsing awesome-aiogram, I saw a paragraph - templates. After getting to know them a little, I rewrote my bot.

Latand vs Tishka17 ⚔️

These are the nicknames of two authors whose templates I used. Here are links to them: Latand/aiogram-bot-template and Tishka17/tgbot_template Now we will look at the difference, advantages and disadvantages.

	Latand	Tishka17
Registering handlers	Here we have the `__init__.py` file where all the other handler files are imported. And inside them, we import the dispatcher object.	In each of the files with handlers, we have a function that registers the handler. And then we call these functions in some main file when starting the bot
Starting the bot	This is where we usually run the command `python main.py`.	A different structure is used here, which allows you to run a bot like a cli.

Although they are similar in their own way, and Latand eventually also switched to Tishka's template, they have their flaws:

👿 The most common error that occurs when using the Latand's template is ImportError(circular import). And to solve it, you have to do ugly things;
👿 When you use Tishka's template, the code increases, namely the registration of handlers:

    register_admin(dp)
    register_user(dp)
    register_admin(dp)
    # and so on...

I thought, "Why not make my own template?"

My own template 😎

Yes, I took the best of both previous templates and made my own. You can download it by this link or just clone it with git:

git clone https://github.com/mezgoodle/bot_template.git

So, let's look at the code and understand how and where to write it. The only thing, I would ask you to ignore the files that are already there. They are just for better understanding.

First of all, we have the following file structure.

📦bot_template-main
┣ 📂tgbot
┃ ┣ 📂filters
┃ ┃ ┗ 📜__init__.py
┃ ┣ 📂handlers
┃ ┃ ┣ 📜errors.py
┃ ┃ ┗ 📜__init__.py
┃ ┣ 📂keyboards
┃ ┃ ┣ 📂inline
┃ ┃ ┃ ┗ 📜__init__.py
┃ ┃ ┣ 📂reply
┃ ┃ ┃ ┗ 📜__init__.py
┃ ┃ ┗ 📜__init__.py
┃ ┣ 📂middlewares
┃ ┃ ┣ 📜throttling.py
┃ ┃ ┗ 📜__init__.py
┃ ┣ 📂misc
┃ ┃ ┗ 📜__init__.py
┃ ┣ 📂models
┃ ┃ ┗ 📜__init__.py
┃ ┣ 📂services
┃ ┃ ┣ 📜admins_notify.py
┃ ┃ ┣ 📜setting_commands.py
┃ ┃ ┗ 📜__init__.py
┃ ┣ 📂states
┃ ┃ ┗ 📜__init__.py
┃ ┣ 📜config.py
┃ ┗ 📜__init__.py
┣ 📜.gitignore
┣ 📜bot.py
┣ 📜LICENSE
┣ 📜loader.py
┣ 📜README.md
┗ 📜requirements.txt

So, to begin with, we will consider two main files: bot.py and loader.py.

loader.py

from aiogram import Bot, Dispatcher
from aiogram.contrib.fsm_storage.memory import MemoryStorage

from tgbot.config import load_config

config = load_config()
storage = MemoryStorage()
bot = Bot(token=config.tg_bot.token, parse_mode='HTML')
dp = Dispatcher(bot, storage=storage)
bot['config'] = config

Here we only initialize the objects of the bot and the dispatcher (as for storage, then in the next articles), and also set the config value through the key.

bot.py

import functools
import logging
import os

from aiogram import Dispatcher
from aiogram.utils.executor import start_polling, start_webhook

from tgbot.config import load_config
from tgbot.filters.admin import IsAdminFilter
from tgbot.middlewares.throttling import ThrottlingMiddleware
from tgbot.services.setting_commands import set_default_commands
from loader import dp

logger = logging.getLogger(__name__)


def register_all_middlewares(dispatcher: Dispatcher) -> None:
    logger.info('Registering middlewares')
    dispatcher.setup_middleware(ThrottlingMiddleware())


def register_all_filters(dispatcher: Dispatcher) -> None:
    logger.info('Registering filters')
    dispatcher.filters_factory.bind(IsAdminFilter)


def register_all_handlers(dispatcher: Dispatcher) -> None:
    from tgbot import handlers
    logger.info('Registering handlers')


async def register_all_commands(dispatcher: Dispatcher) -> None:
    logger.info('Registering commands')
    await set_default_commands(dispatcher.bot)


async def on_startup(dispatcher: Dispatcher, webhook_url: str = None) -> None:
    register_all_middlewares(dispatcher)
    register_all_filters(dispatcher)
    register_all_handlers(dispatcher)
    await register_all_commands(dispatcher)
    # Get current webhook status
    webhook = await dispatcher.bot.get_webhook_info()

    if webhook_url:
        await dispatcher.bot.set_webhook(webhook_url)
        logger.info('Webhook was set')
    elif webhook.url:
        await dispatcher.bot.delete_webhook()
        logger.info('Webhook was deleted')
    logger.info('Bot started')


async def on_shutdown(dispatcher: Dispatcher) -> None:
    await dispatcher.storage.close()
    await dispatcher.storage.wait_closed()
    logger.info('Bot shutdown')


if __name__ == '__main__':
    logging.basicConfig(
        level=logging.INFO,
        format=u'%(filename)s:%(lineno)d #%(levelname)-8s [%(asctime)s] - %(name)s - %(message)s',
    )
    config = load_config()

    # Webhook settings
    HEROKU_APP_NAME = os.getenv('HEROKU_APP_NAME')
    WEBHOOK_HOST = f'https://{HEROKU_APP_NAME}.herokuapp.com'
    WEBHOOK_PATH = f'/webhook/{config.tg_bot.token}'
    WEBHOOK_URL = f'{WEBHOOK_HOST}{WEBHOOK_PATH}'
    # Webserver settings
    WEBAPP_HOST = '0.0.0.0'
    WEBAPP_PORT = int(os.getenv('PORT', 5000))

    start_polling(
        dispatcher=dp,
        on_startup=on_startup,
        on_shutdown=on_shutdown,
        skip_updates=True,
    )

    # start_webhook(
    #     dispatcher=dp,
    #     on_startup=functools.partial(on_startup, webhook_url=WEBHOOK_URL),
    #     on_shutdown=on_shutdown,
    #     webhook_path=WEBHOOK_PATH,
    #     skip_updates=True,
    #     host=WEBAPP_HOST,
    #     port=WEBAPP_PORT
    # )

This is the place where our entire bot "gathers". Here are also handlers, filters, and middleware (about all this, in the following articles). We have a function that is executed when the file is launched with the python bot.py command. Function, in turn, starts long polling for the bot (commented - starting the bot in the state of webhooks). Next, the on_startup function is executed, and everything else is in it. This approach allows us to monitor each stage and run functions independently.

Now let's move on to the tgbot module. There is one main file here - config.py.

import os
from dataclasses import dataclass


@dataclass
class DbConfig:
    host: str
    password: str
    user: str
    database: str


@dataclass
class TgBot:
    token: str


@dataclass
class Config:
    tg_bot: TgBot
    db: DbConfig


def load_config(path: str = None) -> Config:
    # load_dotenv(path)
    return Config(
        tg_bot=TgBot(
            token=os.getenv('BOT_TOKEN', 'token'),
        ),
        db=DbConfig(
            host=os.getenv('DB_HOST', 'localhost'),
            password=os.getenv('DB_PASSWORD', 'password'),
            user=os.getenv('DB_USER', 'user'),
            database=os.getenv('DB_NAME', 'database'),
        ),
    )

I am using dataclasses here to store data.

Looking from top to bottom, there are several folders: filters, keyboards/reply, keyboards/inline, middlewares, misc, models, services, states. There is no point in talking about most of them now, as they will be separate articles. But, for example, the misk folder contains various functions that are not directly related to the bot's logic; services - has two files: admins_notify.py (for notifying the user that the bot has started) and setting_commands.py (for setting commands in the bot menu). We are most interested in the handlers folder.

For example, let's make the echo bot again. Create echo.py in the handlers folder with code:

from aiogram.types import Message

from loader import dp


@dp.message_handler()
async def echo(message: Message) -> Message:
    await message.answer(message.text)

Next in the handlers/__init__.py, we need to do an import:

from . import echo

The end 🏁

And that's all. We made an echo bot with a following file structure. In the next articles, we will complicate it by adding various interesting things to it. Since, in my opinion, this is a difficult topic, do not hesitate to ask me questions by mail or Telegram.

Thank you for reading! ❤️ ❤️ ❤️

Telegram Bots for Begginers

Maksym Zavalniuk — Sun, 14 Aug 2022 17:58:30 +0000

Short overview 📖

Telegram has a huge API interface, and the development of bots is currently increasing very quickly and is in great demand. For beginners, this is a nice opportunity to get the first job and a good salary. The question arises: how to start writing a bot?

✔In this post, you'll find information on:

which language to choose;
which frameworks to use;
how to improve bot development;
what to do next.

How to choose the language? 🤔

Honestly, write in the language that is closest to you. There is no gold standard. Let's see why. As you know, to get data from an API, you need to write a script that makes HTTP requests. For example, getting data from GitHub API, it will look like this:

in Python (with requests package)

>>> response = requests.get('https://api.github.com')
>>> response.content
b'{"current_user_url":"https://api.github.com/user","current_user_authorizations_html_url":"https://github.com/settings/connections/applications{/client_id}","authorizations_url":"https://api.github.com/authorizations","code_search_url":"https://api.github.com/search/code?q={query}{&page,per_page,sort,order}","commit_search_url":"https://api.github.com/search/commits?q={query}{&page,per_page,sort,order}","emails_url":"https://api.github.com/user/emails","emojis_url":"https://api.github.com/emojis","events_url":"https://api.github.com/events","feeds_url":"https://api.github.com/feeds","followers_url":"https://api.github.com/user/followers","following_url":"https://api.github.com/user/following{/target}","gists_url":"https://api.github.com/gists{/gist_id}","hub_url":"https://api.github.com/hub","issue_search_url":"https://api.github.com/search/issues?q={query}{&page,per_page,sort,order}","issues_url":"https://api.github.com/issues","keys_url":"https://api.github.com/user/keys","notifications_url":"https://api.github.com/notifications","organization_repositories_url":"https://api.github.com/orgs/{org}/repos{?type,page,per_page,sort}","organization_url":"https://api.github.com/orgs/{org}","public_gists_url":"https://api.github.com/gists/public","rate_limit_url":"https://api.github.com/rate_limit","repository_url":"https://api.github.com/repos/{owner}/{repo}","repository_search_url":"https://api.github.com/search/repositories?q={query}{&page,per_page,sort,order}","current_user_repositories_url":"https://api.github.com/user/repos{?type,page,per_page,sort}","starred_url":"https://api.github.com/user/starred{/owner}{/repo}","starred_gists_url":"https://api.github.com/gists/starred","team_url":"https://api.github.com/teams","user_url":"https://api.github.com/users/{user}","user_organizations_url":"https://api.github.com/user/orgs","user_repositories_url":"https://api.github.com/users/{user}/repos{?type,page,per_page,sort}","user_search_url":"https://api.github.com/search/users?q={query}{&page,per_page,sort,order}"}'

in JavaScript (with fetch method)

fetch('https://api.github.com')
  .then(response => response.json())
  .then(data => {
    console.log(data)
  })
  .catch(error => console.error(error))
// data from the response is:
{
  current_user_url: 'https://api.github.com/user',
  current_user_authorizations_html_url: 'https://github.com/settings/connections/applications{/client_id}',
  authorizations_url: 'https://api.github.com/authorizations',
  code_search_url: 'https://api.github.com/search/code?q={query}{&page,per_page,sort,order}',
  commit_search_url: 'https://api.github.com/search/commits?q={query}{&page,per_page,sort,order}',
  emails_url: 'https://api.github.com/user/emails',
  emojis_url: 'https://api.github.com/emojis',
  events_url: 'https://api.github.com/events',
  feeds_url: 'https://api.github.com/feeds',
  followers_url: 'https://api.github.com/user/followers',
  following_url: 'https://api.github.com/user/following{/target}',
  gists_url: 'https://api.github.com/gists{/gist_id}',
  hub_url: 'https://api.github.com/hub',
  issue_search_url: 'https://api.github.com/search/issues?q={query}{&page,per_page,sort,order}',
  issues_url: 'https://api.github.com/issues',
  keys_url: 'https://api.github.com/user/keys',
  label_search_url: 'https://api.github.com/search/labels?q={query}&repository_id={repository_id}{&page,per_page}',
  notifications_url: 'https://api.github.com/notifications',
  organization_url: 'https://api.github.com/orgs/{org}',
  organization_repositories_url: 'https://api.github.com/orgs/{org}/repos{?type,page,per_page,sort}',
  organization_teams_url: 'https://api.github.com/orgs/{org}/teams',
  public_gists_url: 'https://api.github.com/gists/public',
  rate_limit_url: 'https://api.github.com/rate_limit',
  repository_url: 'https://api.github.com/repos/{owner}/{repo}',
  repository_search_url: 'https://api.github.com/search/repositories?q={query}{&page,per_page,sort,order}',
  current_user_repositories_url: 'https://api.github.com/user/repos{?type,page,per_page,sort}',
  starred_url: 'https://api.github.com/user/starred{/owner}{/repo}',
  starred_gists_url: 'https://api.github.com/gists/starred',
  topic_search_url: 'https://api.github.com/search/topics?q={query}{&page,per_page}',
  user_url: 'https://api.github.com/users/{user}',
  user_organizations_url: 'https://api.github.com/user/orgs',
  user_repositories_url: 'https://api.github.com/users/{user}/repos{?type,page,per_page,sort}',
  user_search_url: 'https://api.github.com/search/users?q={query}{&page,per_page,sort,order}'
}

in GoLang (with http package)

package main

import (
    "net/http"
    "io/ioutil"
    "log"
)

func main() {
    res, err := http.Get("https://api.github.com")
    if err != nil {
      log.Fatal(err)
    }

    // read body
    body, err := ioutil.ReadAll(res.Body)
    res.Body.Close()
    if err != nil {
      log.Fatal(err)
    }

    if res.StatusCode != 200 {
      log.Fatal("Unexpected status code", res.StatusCode)
    }

    log.Printf("Body: %s\n", body)
}
// body from the response is:
Body: {"current_user_url":"https://api.github.com/user","current_user_authorizations_html_url":"https://github.com/settings/connections/applications{/client_id}","authorizations_url":"https://api.github.com/authorizations","code_search_url":"https://api.github.com/search/code?q={query}{&page,per_page,sort,order}","commit_search_url":"https://api.github.com/search/commits?q={query}{&page,per_page,sort,order}","emails_url":"https://api.github.com/user/emails","emojis_url":"https://api.github.com/emojis","events_url":"https://api.github.com/events","feeds_url":"https://api.github.com/feeds","followers_url":"https://api.github.com/user/followers","following_url":"https://api.github.com/user/following{/target}","gists_url":"https://api.github.com/gists{/gist_id}","hub_url":"https://api.github.com/hub","issue_search_url":"https://api.github.com/search/issues?q={query}{&page,per_page,sort,order}","issues_url":"https://api.github.com/issues","keys_url":"https://api.github.com/user/keys","label_search_url":"https://api.github.com/search/labels?q={query}&repository_id={repository_id}{&page,per_page}","notifications_url":"https://api.github.com/notifications","organization_url":"https://api.github.com/orgs/{org}","organization_repositories_url":"https://api.github.com/orgs/{org}/repos{?type,page,per_page,sort}","organization_teams_url":"https://api.github.com/orgs/{org}/teams","public_gists_url":"https://api.github.com/gists/public","rate_limit_url":"https://api.github.com/rate_limit","repository_url":"https://api.github.com/repos/{owner}/{repo}","repository_search_url":"https://api.github.com/search/repositories?q={query}{&page,per_page,sort,order}","current_user_repositories_url":"https://api.github.com/user/repos{?type,page,per_page,sort}","starred_url":"https://api.github.com/user/starred{/owner}{/repo}","starred_gists_url":"https://api.github.com/gists/starred","topic_search_url":"https://api.github.com/search/topics?q={query}{&page,per_page}","user_url":"https://api.github.com/users/{user}","user_organizations_url":"https://api.github.com/user/orgs","user_repositories_url":"https://api.github.com/users/{user}/repos{?type,page,per_page,sort}","user_search_url":"https://api.github.com/search/users?q={query}{&page,per_page,sort,order}"}

As you can see from the code execution results, there is no difference. So just choose the language in which you write. 😊

How to choose the framework? 🏎️

Of course, it's good to write API requests yourself. It reduces the dependency on third-party libraries and allows you to control the behavior of the code more. But when there are more such methods than twenty, it already increases the size of the code. It becomes difficult to manage all the logic. This is where third-party libraries(frameworks) come to the rescue. After choosing a language, you can consider the options of different libraries from the list here, on the official Telegram page. For JavaScript I recommend using node-telegram-bot-api and telegraf. For Python you can take pyTelegramBotAPI and aiogram(highly recommended).

Let's start coding the first bot 🐱‍💻

Since I mostly write code in Python, I suggest you start developing bots with the aiogram. Aiogram is a pretty simple and fully asynchronous framework for Telegram Bot API written in Python 3.7 with asyncio and aiohttp. It helps you to make your bots faster and simpler.

Install the package. We can do this by pip. Also, other ways to download the library are listed here.
```
pip install -U aiogram
```
Let's create a project structure. We need two python files: config.py and main.py. It will look like this:
Getting the token. The token is a string along the lines of 110201543:AAHdqTcvCH1vGWJxfSeofSAs0K5PALDsaw that is required to authorize the bot and send requests to the Bot API. Keep your token secure and store it safely, it can be used by anyone to control your bot. To create a new one, you need to "talk" to the @BotFather and get a token there.

Write some start code. First of all, copy the token from the BotFater and paste it to the config.py. We use the os module to work with environment variables. It's a good solution to keep your token secret. While you are in the development stage, the token can be visible to you. But in the production stage, remove it.

import os

API_TOKEN = os.getenv('TOKEN', '5135575762:AAF9vytvlcuL-hruAHHMgZ3G2WvLpbZXMSI')

In the main.py we need to import the logging module, aiogram objects, and API_TOKEN from config.py.

import logging

from aiogram import Bot, Dispatcher, executor
from aiogram.types import Message

from config import API_TOKEN

Now let's initialize bot and dispatcher objects:

# Configure logging
logging.basicConfig(level=logging.INFO)

# Initialize bot and dispatcher
bot = Bot(token=API_TOKEN)
dp = Dispatcher(bot)

Next step: interaction with bots starts with one command. We can handle commands from users like this:

@dp.message_handler(commands=['start', 'help'])
async def handle_start(message: Message) -> Message:
    return await message.reply("Hi!\nI'm TestBot!")

Also, we add one more handler to catch all text messages:

@dp.message_handler()
async def echo(message: Message) -> Message:
    return await message.answer(message.text)

The last step: run long polling. This command will run our bot to catch all updates from Telegram API every second:

if __name__ == '__main__':
    executor.start_polling(dp, skip_updates=True)

In summary, we have two files:

config.py

import os

API_TOKEN = os.getenv('TOKEN', '5135575762:AAF9vytvlcuL-hruAHHMgZ3G2WvLpbZXMSI')

main.py

import logging

from aiogram import Bot, Dispatcher, executor
from aiogram.types import Message

from config import API_TOKEN


# Configure logging
logging.basicConfig(level=logging.INFO)

# Initialize bot and dispatcher
bot = Bot(token=API_TOKEN)
dp = Dispatcher(bot)


@dp.message_handler(commands=['start', 'help'])
async def handle_start(message: Message) -> Message:
    return await message.reply("Hi!\nI'm TestBot!")


@dp.message_handler()
async def echo(message: Message) -> Message:
    return await message.answer(message.text)


if __name__ == '__main__':
    executor.start_polling(dp, skip_updates=True)

What we got in the end?🤩

Let's run our bot with the command in the terminal:

python main.py

In the console you will something like this:

INFO:aiogram:Bot: testbot [@testmezgoodlebot]
WARNING:aiogram:Updates were skipped successfully.
INFO:aiogram.dispatcher.dispatcher:Start polling.

Now let's go to the Telegram and start chatting with the bot

To start a chat with the bot, follow the link provided by BotFather.

I hope, you have a result like mine 😺

Congratulations! You've written your first bot! ✨

Yes, now this is a simple echo-bot, but in future posts, we will cover all aspects of bot development. Then you can already create bots of any complexity. So, wait for my next new posts.

References:

Bot code on GitHub

Thank you for reading! ❤️ ❤️ ❤️