DEV Community: King Triton

Telegram Bot @ChatGPTTlgrmBot Updated to GPT-5.1: New Features and Promo Code

King Triton — Sat, 15 Nov 2025 15:27:47 +0000

OpenAI has released the new GPT-5.1, and I didn’t waste any time updating my Telegram bot @ChatGPTTlgrmBot. Now the bot responds using the latest model, which the company describes as “warmer, more intelligent, and better at following instructions.” Even FastCompany confirms: GPT-5.1 is “smarter and more conversational.” To keep up with the hype around the update, several new features have been added to the bot:

GPT-5.1 Support – The bot now runs on OpenAI’s latest model. According to OpenAI, GPT-5.1 Instant is “our most-used model, now warmer, more intelligent, and better at following instructions.” In simple terms, the responses are livelier, clearer, and sometimes friendlier.
Promo Code System – I added promo code CRTD5, which gives +3 free queries (use the /promo command). This addresses a past issue: one free query was too little, so now new users are welcomed more generously.
More Free Queries for New Users – Instead of 1, you now get 3 free queries on the first bot launch.
Convenient and Transparent Payments – Query payments still go through Telegram Stars (⭐): one star costs around 5 ₽, and 1 query = 1 star. Stars are purchased directly in Telegram. Telegram Stars are the app’s internal currency for paying for digital goods and services.

How to Use the Bot

Using it remains intuitively simple:

Open the bot @ChatGPTTlgrmBot and type /start. You will receive 3 free queries.
Ask a question in any language: the bot answers on any topic, just like before.
If free queries run out, you can get more for free: enter /promo and use code CRTD5. This will give you +3 more free queries.
Purchasing queries: enter the /buy command. Specify a number (any: 1, 5, 10, 25, etc.) or click a button in the menu. Pay via Telegram Stars (⭐) and your queries will be activated.

Why I Did This

Honestly, the reason is simple: I love experimenting with AI and didn’t want to miss the moment. OpenAI released GPT-5.1, everyone is talking about it, so I had to follow the trend. I already had a Telegram bot on ChatGPT, and the first project articles were even written by the AI itself. Updating to GPT-5.1 is a great excuse to level up the project and test the demand.

Open Source Code

The project repository on GitHub is open under the MIT license. Why? I see several benefits:

Portfolio: The code (Python + Telegram Bot API + OpenAI API) is visible to everyone – a live showcase of my skills.
Trust: Open code earns respect – users see there’s nothing to hide.
Community Help: The example may help someone build their own bot or inspire a startup.
Feedback: With open source, I immediately receive PRs, bug reports, and suggestions that help improve the project.

Try It Out

To explore all the new features, go to @ChatGPTTlgrmBot on Telegram. The first question will definitely be free (actually three). If you have questions or ideas, message @king_triton. Also, we have a Telegram channel “ChatGPT Created” – check it out for lots of fun and useful AI content.

P.S. I hope GPT-5.1 will make the bot even more enjoyable. Hugs to everyone and good luck with your new queries!

Building a GPT-5 Telegram Bot with Telegram Stars Monetization

King Triton — Sun, 02 Nov 2025 06:01:04 +0000

Introduction

Have you ever wanted to provide AI-powered services but found ChatGPT's $20/month subscription too expensive for casual users? I built a Telegram bot that offers GPT-5 access for just 1 Telegram Star per request - making AI accessible and affordable for everyone.

In this article, I'll walk you through building a monetized AI chatbot using Telegram's native payment system (Telegram Stars), OpenAI's GPT-5 API, and Python.

Try the bot: @ChatGPTTlgrmBot

Source code: GitHub Repository

💡 The Idea

The concept is simple but powerful:

Pay-per-use model: 1 Telegram Star = 1 AI request
No subscriptions: Users only pay for what they use
Lower barrier to entry: Much cheaper than $20/month ChatGPT Plus
Built-in payments: Telegram Stars integration means no external payment processors

🛠 Tech Stack

Core Technologies

Python 3.7+ - Main programming language
pyTelegramBotAPI - Telegram Bot API wrapper
OpenAI Python SDK - For GPT-5 integration
SQLite3 - Lightweight database for user data and transactions
python-dotenv - Environment variable management
Telegram Stars - Native Telegram payment system

Why These Technologies?

Python: Easy to read, fast to develop, excellent libraries
SQLite: Zero configuration, perfect for small to medium scale
Telegram Stars: No payment processor fees, instant transactions, built into Telegram
OpenAI API: Direct access to GPT-5, simple REST API

📐 Architecture Overview

┌─────────────┐
│   User      │
│  (Telegram) │
└──────┬──────┘
       │
       ▼
┌─────────────────┐
│  Telegram Bot   │
│   (bot.py)      │
└────┬──────┬─────┘
     │      │
     │      ▼
     │  ┌──────────────┐
     │  │  OpenAI API  │
     │  │   (GPT-5)    │
     │  └──────────────┘
     │
     ▼
┌─────────────────┐
│  SQLite DB      │
│  - Users        │
│  - Requests     │
│  - Payments     │
└─────────────────┘

🔧 Implementation

1. Project Structure

chatgpt-telegram-bot/
├── bot.py           # Main bot logic
├── functions.py     # OpenAI API integration
├── db.py           # Database management
├── config.py       # Configuration loader
├── .env            # Environment variables
├── requirements.txt
└── README.md

2. Database Schema

# db.py
import sqlite3
from threading import Lock

class DatabaseManager:
    def __init__(self, db_name='bot.db'):
        self.db_name = db_name
        self.lock = Lock()

    def create_tables(self):
        with self.lock, sqlite3.connect(self.db_name) as conn:
            cursor = conn.cursor()

            # Users table - unified balance
            cursor.execute('''CREATE TABLE IF NOT EXISTS users (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                tg_id INTEGER UNIQUE NOT NULL,
                requests INTEGER DEFAULT 3,
                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
            )''')

            # Requests history with token metrics
            cursor.execute('''CREATE TABLE IF NOT EXISTS results (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                tg_id INTEGER NOT NULL,
                prompt TEXT NOT NULL,
                result TEXT NOT NULL,
                prompt_tokens INTEGER DEFAULT 0,
                completion_tokens INTEGER DEFAULT 0,
                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
            )''')

            # Payment transactions
            cursor.execute('''CREATE TABLE IF NOT EXISTS payments (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                tg_id INTEGER NOT NULL,
                amount INTEGER NOT NULL,
                stars_paid INTEGER NOT NULL,
                payment_id TEXT,
                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
            )''')

            conn.commit()

Key Design Decisions:

Unified balance: Single requests field instead of separate free/paid
Token tracking: Monitor API usage for cost optimization
Payment audit trail: Complete transaction history

3. OpenAI Integration

# functions.py
from openai import OpenAI
from config import AI_TOKEN

client = OpenAI(api_key=AI_TOKEN)

def get_openai_response(message: str, effort: str = "low", 
                       verbosity: str = "low"):
    """
    Get response from GPT-5 using new Responses API
    Returns: (text, prompt_tokens, completion_tokens)
    """
    try:
        result = client.responses.create(
            model="gpt-5",
            input=message,
            reasoning={"effort": effort},
            text={"verbosity": verbosity},
        )

        text = result.output_text
        usage = getattr(result, "usage", None)
        prompt_tokens = getattr(usage, "input_tokens", 0)
        completion_tokens = getattr(usage, "output_tokens", 0)

        return text, prompt_tokens, completion_tokens

    except Exception as e:
        print(f"Error in OpenAI API: {e}")
        return f"Error: {e}", 0, 0

Why the new Responses API?

Simplified interface compared to Chat Completions
Built-in reasoning control
Better token management

4. Telegram Bot Core

# bot.py
import telebot
from telebot import types

bot = telebot.TeleBot(BOT_TOKEN)

# Dictionary to track users entering custom amounts
waiting_for_amount = {}

@bot.message_handler(commands=['start'])
def send_welcome(message):
    db_manager.add_user(message.chat.id, initial_requests=3)
    requests = db_manager.get_user_requests(message.chat.id)

    welcome_text = (
        "👋 Welcome! I'm your GPT-5 AI assistant.\n\n"
        f"💰 Your balance: {requests} requests\n\n"
        "Send me a message (min 10 characters) and I'll help!\n\n"
        "Commands:\n"
        "/start - start bot\n"
        "/help - get help\n"
        "/balance - check balance\n"
        "/buy - purchase requests\n"
        "/dev - about developer"
    )
    bot.reply_to(message, welcome_text)

5. Telegram Stars Payment Integration

@bot.message_handler(commands=['buy'])
def buy_requests(message):
    markup = types.InlineKeyboardMarkup(row_width=3)

    # Quick purchase options
    buttons = [
        types.InlineKeyboardButton("1 ⭐", callback_data="buy_1"),
        types.InlineKeyboardButton("5 ⭐", callback_data="buy_5"),
        types.InlineKeyboardButton("10 ⭐", callback_data="buy_10"),
        types.InlineKeyboardButton("25 ⭐", callback_data="buy_25"),
        types.InlineKeyboardButton("50 ⭐", callback_data="buy_50"),
        types.InlineKeyboardButton("100 ⭐", callback_data="buy_100"),
    ]
    markup.add(*buttons)

    # Custom amount button
    custom_button = types.InlineKeyboardButton(
        "✏️ Custom Amount", 
        callback_data="buy_custom"
    )
    markup.add(custom_button)

    bot.send_message(
        message.chat.id, 
        "💳 Purchase Requests\n\n1 request = 1 ⭐ Telegram Star", 
        reply_markup=markup
    )

@bot.callback_query_handler(func=lambda call: call.data.startswith('buy_'))
def process_buy(call):
    if call.data == 'buy_custom':
        waiting_for_amount[call.from_user.id] = True
        bot.send_message(
            call.message.chat.id,
            "✏️ Enter amount (1-1000):"
        )
        return

    amount = int(call.data.split('_')[1])
    create_invoice(call.message.chat.id, call.from_user.id, amount)

def create_invoice(chat_id, user_id, amount):
    """Create Telegram Stars invoice"""
    prices = [types.LabeledPrice(
        label=f"{amount} requests", 
        amount=amount
    )]

    bot.send_invoice(
        chat_id=chat_id,
        title=f"Purchase {amount} requests",
        description=f"Buy {amount} requests to GPT-5 bot",
        invoice_payload=f"requests_{amount}_{user_id}",
        provider_token="",  # Empty for Telegram Stars
        currency="XTR",  # Telegram Stars currency code
        prices=prices
    )

@bot.pre_checkout_query_handler(func=lambda query: True)
def process_pre_checkout(pre_checkout_query):
    """Confirm payment"""
    bot.answer_pre_checkout_query(pre_checkout_query.id, ok=True)

@bot.message_handler(content_types=['successful_payment'])
def process_successful_payment(message):
    """Handle successful payment"""
    payment_info = message.successful_payment

    # Parse payload
    payload_parts = payment_info.invoice_payload.split('_')
    amount = int(payload_parts[1])
    user_id = int(payload_parts[2])

    # Add requests to user
    db_manager.add_requests(user_id, amount)

    # Save payment record
    db_manager.add_payment(
        tg_id=user_id,
        amount=amount,
        stars_paid=amount,
        payment_id=payment_info.telegram_payment_charge_id
    )

    requests = db_manager.get_user_requests(user_id)
    bot.send_message(
        message.chat.id,
        f"✅ Payment successful!\n\n"
        f"➕ Added: {amount} requests\n"
        f"💰 New balance: {requests} requests"
    )

Telegram Stars Benefits:

No external payment processor needed
No transaction fees (Telegram takes a small cut)
Instant confirmation
Built into Telegram app
Supports custom amounts

6. Message Processing

@bot.message_handler(func=lambda message: True)
def generate_result(message):
    # Check if waiting for custom amount input
    if message.from_user.id in waiting_for_amount:
        try:
            amount = int(message.text.strip())
            if 1 <= amount <= 1000:
                del waiting_for_amount[message.from_user.id]
                create_invoice(
                    message.chat.id, 
                    message.from_user.id, 
                    amount
                )
            else:
                bot.send_message(
                    message.chat.id,
                    "❌ Invalid amount! Enter 1-1000:"
                )
            return
        except ValueError:
            bot.send_message(
                message.chat.id,
                "❌ Please enter a number:"
            )
            return

    # Validate message length
    if len(message.text) < 10:
        bot.send_message(
            message.chat.id,
            "⚠️ Message too short (min 10 characters)"
        )
        return

    if len(message.text) > 4000:
        bot.send_message(
            message.chat.id,
            "⚠️ Message too long (max 4000 characters)"
        )
        return

    # Check balance
    requests = db_manager.get_user_requests(message.chat.id)
    if requests <= 0:
        bot.send_message(
            message.chat.id,
            "❌ No requests left! Use /buy to purchase more.\n"
            "1 request = 1 ⭐ Telegram Star"
        )
        return

    # Show typing indicator
    bot.send_chat_action(message.chat.id, 'typing')

    try:
        # Get GPT-5 response
        response_text, prompt_tokens, completion_tokens = \
            get_openai_response(message.text)

        # Deduct request
        if db_manager.use_request(message.chat.id):
            # Save to database
            db_manager.add_result(
                message.chat.id,
                message.text,
                response_text,
                prompt_tokens,
                completion_tokens
            )

            # Send response
            bot.reply_to(message, response_text)

            # Show remaining balance
            requests = db_manager.get_user_requests(message.chat.id)
            if requests > 0:
                bot.send_message(
                    message.chat.id,
                    f"💰 Remaining: {requests} requests"
                )
            else:
                bot.send_message(
                    message.chat.id,
                    "❌ No requests left! Use /buy to purchase more."
                )
    except Exception as e:
        bot.reply_to(message, f"❌ Error: {str(e)}")

🎯 Key Features Implemented

1. Flexible Payment System

Quick purchase buttons (1, 5, 10, 25, 50, 100 Stars)
Custom amount input (1-1000)
State management for user input flow

2. User Experience

Typing indicator: Shows bot is processing
Balance feedback: After each request
Clear pricing: 1 Star = 1 Request
Free trial: 3 free requests for new users

3. Admin Dashboard

@bot.message_handler(commands=['stats'])
def show_stats(message):
    if message.from_user.id == ADMIN_ID:
        total_users = db_manager.get_total_users()
        total_requests = db_manager.get_total_requests()
        total_revenue = db_manager.get_total_revenue()

        bot.reply_to(
            message,
            f"📊 Bot Statistics:\n\n"
            f"👥 Total users: {total_users}\n"
            f"💬 Total requests: {total_requests}\n"
            f"⭐ Revenue: {total_revenue} Stars"
        )

📊 Performance & Scalability

Current Setup

Database: SQLite with threading locks
Suitable for: Up to 10,000 users
Response time: 2-5 seconds (depends on OpenAI API)

Scaling Considerations

For larger scale, consider:

PostgreSQL/MySQL: Better concurrent access
Redis: For session management and caching
Message Queue: For handling spike loads
Load Balancer: Multiple bot instances

💰 Cost Analysis

Running Costs

Server: $5-10/month (VPS)
OpenAI API: ~$0.03-0.15 per request (GPT-5)
Telegram Stars: ~30% commission to Telegram

Pricing Strategy

1 Star ≈ $0.013 (varies by region)
Profit margin: ~20-40% after API costs
Break-even: ~500 paid requests/month

🔒 Security Best Practices

Environment Variables: Never commit .env files
Input Validation: Check message length and content
Rate Limiting: Prevent abuse (can add)
Payment Verification: Always verify payment webhooks
Database Locks: Thread-safe operations
Error Handling: Graceful failure recovery

🚀 Deployment

Quick Deploy Script

#!/bin/bash

# Clone repository
git clone https://github.com/king-tri-ton/chatgpt-telegram-bot.git
cd chatgpt-telegram-bot

# Install dependencies
pip install -r requirements.txt

# Setup environment
cp .env.example .env
nano .env  # Edit with your tokens

# Run bot
python bot.py

Using systemd (Linux)

[Unit]
Description=GPT-5 Telegram Bot
After=network.target

[Service]
Type=simple
User=youruser
WorkingDirectory=/path/to/bot
ExecStart=/usr/bin/python3 bot.py
Restart=always

[Install]
WantedBy=multi-user.target

📈 Future Improvements

[ ] Image generation support (DALL-E)
[ ] Conversation history/context
[ ] Referral system
[ ] Subscription plans
[ ] Multi-language support
[ ] Voice message support
[ ] Analytics dashboard
[ ] A/B testing for pricing

🎓 Lessons Learned

Telegram Stars are game-changing: No payment processor hassle
SQLite is underrated: Perfect for MVPs
User experience matters: Clear pricing, instant feedback
Start simple: Can always add features later
Monitor costs: OpenAI API costs can add up

🤝 Contributing

The project is open-source under MIT license. Contributions welcome!

Ways to contribute:

Report bugs
Suggest features
Submit pull requests
Improve documentation
Share feedback

📚 Resources

🎉 Conclusion

Building a monetized AI bot with Telegram Stars is surprisingly straightforward. The combination of:

Low entry barrier (1 Star per request)
Built-in payments (no Stripe/PayPal)
Powerful AI (GPT-5)
Simple tech stack (Python + SQLite)

...makes this a viable micro-SaaS project.

The bot is live at @ChatGPTTlgrmBot - try it out!

Full source code: GitHub

Questions? Feedback? Drop a comment below or reach out on Telegram: @king_triton

If you found this helpful, please ⭐ the GitHub repo and share with others!

python #telegram #openai #gpt5 #bot #monetization #telegramstars #ai #chatbot #opensource

Learning Node.js in 30 Days with AI - Day 6

King Triton — Fri, 30 Aug 2024 08:08:09 +0000

Today marked Day 6 of my Node.js learning adventure, and I delved into the fascinating world of the EventEmitter class. Here’s how I navigated through it and what I learned along the way.

Theory Recap

The EventEmitter class is a cornerstone in Node.js for managing events. It provides a robust way to create, emit, and handle events, making it essential for building applications that rely on event-driven architecture.

Key Methods of EventEmitter:

on(eventName, listener): Registers a listener for a specific event.
emit(eventName, [...args]): Emits an event, passing optional arguments to listeners.
removeListener(eventName, listener): Removes a specific listener for an event.
once(eventName, listener): Adds a listener that will be triggered only once.

Practical Task

Task: Create custom events and handlers.

I started by creating a class that extends EventEmitter and added custom event handlers. Here’s a step-by-step account of what I did:

Defined the Custom Class:

I created a class called DataProcessor that extends EventEmitter. This class had a method processData to simulate data processing.

   const EventEmitter = require('events');

   class DataProcessor extends EventEmitter {
     processData(data) {
       this.emit('start');

       // Simulate data processing
       setTimeout(() => {
         this.emit('data', data);
         this.emit('end');
       }, 1000);
     }
   }

Set Up Event Handlers:

I then initialized the DataProcessor class and defined handlers for three events: 'start', 'data', and 'end'.

   // Initialization
   const processor = new DataProcessor();

   // Event handlers
   processor.on('start', () => console.log('Processing started...'));
   processor.on('data', (data) => console.log(`Processing data: ${data}`));
   processor.on('end', () => console.log('Processing completed.'));

Emitted Events:

Finally, I called the processData method to see the events in action.

   processor.processData('Some data');

Watching the sequence of events unfold was enlightening. The console output showed the flow from starting the process to handling data and completing it.

Independent Task

Task: Develop a notification system using events.

For the independent task, I designed a Notifier class. Here’s how I approached it:

Created the Notifier Class:

   const EventEmitter = require('events');

   class Notifier extends EventEmitter {
     constructor() {
       super();
       this.notifications = [];
     }

     addNotification(notification) {
       if (typeof notification !== 'string') {
         this.emit('error', 'Notification must be a string');
         return;
       }

       this.notifications.push(notification);
       this.emit('notify', notification);

       if (this.notifications.length > 0) {
         this.emit('complete');
       }
     }
   }

Defined Event Handlers:

I set up handlers for 'notify', 'error', and 'complete'.

   const notifier = new Notifier();

   notifier.on('notify', (message) => console.log(`New notification: ${message}`));
   notifier.on('error', (err) => console.error(`Error: ${err}`));
   notifier.on('complete', () => console.log('All notifications processed.'));

Tested the System:

I tested the system by adding notifications and handling potential errors.

   notifier.addNotification('This is your first notification.');
   notifier.addNotification('This is your second notification.');
   notifier.addNotification(123); // This should trigger an error

It was satisfying to see how the notifications were handled, errors were reported, and the completion event was triggered.

Conclusion

Today’s exploration of EventEmitter has significantly deepened my understanding of event-driven programming in Node.js. Implementing custom events and handlers was a great way to see how events flow and how they can be managed effectively. The independent task further reinforced these concepts and gave me hands-on experience with building a notification system.

I’m excited to continue this journey and see what the next days have in store!

Resources

All lessons created by ChatGPT can be found at: https://king-tri-ton.github.io/learn-nodejs

Learning Node.js in 30 Days with AI - Day 5

King Triton — Thu, 29 Aug 2024 07:31:15 +0000

Diving into File Operations and Streams

As part of my 30-day journey to master Node.js, today I tackled one of the core aspects of backend development: working with files and streams. I already had a solid understanding of JavaScript, but the world of Node.js introduces a whole new set of tools and concepts. Here's what I learned on Day 5.

Understanding the `fs` Module

The day began with an introduction to the fs (File System) module. This module is essential in Node.js, allowing you to interact with the file system directly. I discovered that with fs, I could read, write, delete, and manage files and directories with ease.

What really stood out to me was the asynchronous nature of many of these operations. Node.js handles file operations without blocking the main thread, making it incredibly efficient. For example, using fs.readFile() lets you read a file without pausing the execution of the rest of your code. Here's a snippet of how that looks:

const fs = require('fs');

fs.readFile('example.txt', 'utf8', (err, data) => {
  if (err) throw err;
  console.log(data);
});

This is a simple yet powerful way to handle files, especially in environments where performance and non-blocking operations are crucial.

Streams: Handling Data Efficiently

Next up was the stream module. This concept was new to me, but I quickly saw its value. Streams in Node.js allow you to work with data incrementally, which is perfect for handling large files. Instead of loading an entire file into memory, you can process it piece by piece.

I learned about the different types of streams: Readable, Writable, Duplex, and Transform. The Readable and Writable streams were the most relevant for today’s tasks. I used these to read data from one file and write it to another without overwhelming the system's memory.

Here’s an example of how I used streams to copy the contents of one file to another:

const fs = require('fs');

// Create a read stream for the source file
const readStream = fs.createReadStream('source.txt');

// Create a write stream for the destination file
const writeStream = fs.createWriteStream('destination.txt');

// Pipe the read stream to the write stream to transfer data
readStream.pipe(writeStream);

writeStream.on('finish', () => {
  console.log('File copied successfully!');
});

This code highlights the simplicity and power of streams. The pipe() method was a revelation for me, as it seamlessly connects two streams, making data transfer straightforward and efficient.

Independent Task: Putting It All Together

After grasping the theory, I tackled the independent task: implementing file copying using streams. This was a great way to solidify my understanding.

I created a file called source.txt and used the skills I learned to copy its contents to destination.txt. I also added error handling to ensure the program could handle situations like missing files. This exercise reinforced the importance of streams in managing file operations efficiently in Node.js.

Conclusion

Day 5 was eye-opening. I now have a deeper understanding of how Node.js handles file operations and the significance of streams in managing large files. This knowledge will undoubtedly be useful as I continue my journey to master Node.js.

As I move forward, I'm excited to see how these concepts integrate with more advanced topics. Stay tuned for more insights as I continue learning Node.js in 30 days with the help of AI!

Resources

All lessons created by ChatGPT can be found at: https://king-tri-ton.github.io/learn-nodejs

Learning Node.js in 30 Days with AI - Day 4

King Triton — Wed, 28 Aug 2024 09:36:19 +0000

Today, I continued learning Node.js with the help of ChatGPT, and we focused on asynchronous programming. This is one of the most important concepts in Node.js, and I'm excited to have started mastering it.

Theory

In Node.js, asynchronous programming is crucial due to its non-blocking, event-driven architecture. This means that operations such as file reading, database queries, or network requests do not block the execution of other code while waiting for a result.

We explored three main ways to handle asynchronous operations:

Callbacks: Functions passed as arguments to other functions, which are executed once an asynchronous operation completes.

const fs = require('fs');

fs.readFile('example.txt', 'utf8', (err, data) => {
    if (err) {
        console.error(err);
        return;
    }
    console.log(data);
});

Promises: Objects representing the eventual completion (or failure) of an asynchronous operation and its resulting value. Promises allow chaining and make the code more readable compared to nested callbacks.

const fs = require('fs').promises;

fs.readFile('example.txt', 'utf8')
    .then(data => {
        console.log(data);
    })
    .catch(err => {
        console.error(err);
    });

Async/Await: Syntactic sugar built on top of Promises that allows writing asynchronous code in a synchronous manner.

const fs = require('fs').promises;

async function readFile() {
    try {
        const data = await fs.readFile('example.txt', 'utf8');
        console.log(data);
    } catch (err) {
        console.error(err);
    }
}

readFile();

Practical Task

Today, I practiced converting a callback-based function to a promise-based function.

Original code with callbacks:

const fs = require('fs');

function readFileCallback(path, callback) {
    fs.readFile(path, 'utf8', (err, data) => {
        if (err) {
            callback(err);
            return;
        }
        callback(null, data);
    });
}

readFileCallback('example.txt', (err, data) => {
    if (err) {
        console.error(err);
        return;
    }
    console.log(data);
});

Conversion to Promises:

const fs = require('fs').promises;

function readFilePromise(path) {
    return fs.readFile(path, 'utf8');
}

readFilePromise('example.txt')
    .then(data => {
        console.log(data);
    })
    .catch(err => {
        console.error(err);
    });

Independent Task

I also wrote an asynchronous function using async/await that reads the content of a file and logs it to the console. If an error occurs (e.g., file not found), it should catch the error and log it.

const fs = require('fs').promises;

async function readFileAsync(path) {
    try {
        const data = await fs.readFile(path, 'utf8');
        console.log(data);
    } catch (err) {
        console.error(err);
    }
}

readFileAsync('example.txt');

Resources

All lessons created by ChatGPT can be found at: https://king-tri-ton.github.io/learn-nodejs

Help Needed with Creating a Console Bot Using OpenAI Assistants API

King Triton — Tue, 27 Aug 2024 13:48:40 +0000

Hi everyone,

I'm encountering difficulties while creating a console bot using the OpenAI Assistants API and I hope for your assistance. Here’s the issue:

I created an assistant through Playground and have its ID. My goal now is to create a console bot that interacts with this assistant. The assistant uses only instructions and does not employ any tools. The main task is to ensure the bot responds according to the instructions and also maintains the dialogue history.

I tried using Prompt Engineering, but the problem is that I have to separately save the history (e.g., in JSON) and send it to the API every time for the bot to understand the context. With Assistants API, it seems this is not necessary, as threads are used. However, I’m not entirely sure how this works.

Question: Is it possible to implement a bot using only the assistant’s ID in Python? If so, could you provide some example code or explain how to achieve this? I’ve already gone through the documentation (https://platform.openai.com/docs/assistants/overview) but might have missed something important.

I would appreciate any help!

Thank you!

Learning Node.js in 30 Days with AI - Day 3

King Triton — Tue, 27 Aug 2024 06:27:18 +0000

On the third day of learning Node.js, I read an article written by ChatGPT and learned about working with the console in Node.js. The article covered two main topics: command line arguments and console output.

What I Learned

Command Line Arguments (process.argv)
- process.argv is an array that contains the command line arguments passed when the script is launched.
- The first two elements of the array are the path to Node.js and the path to the script. The remaining elements are the arguments passed during program execution.
- For example, if you run the command node script.js arg1 arg2, the process.argv array will include the path to Node.js, the path to the script, and the arguments arg1 and arg2.
Console Output (console.log)
- console.log is used to output information to the console, which is useful for debugging and displaying the results of your program.
- For example, when you run the code console.log('Hello, World!'), the console will display the message "Hello, World!".

Practical Task

I wrote a program that takes an operation (addition, subtraction, multiplication, division) and two numbers from the command line, performs the specified operation, and outputs the result to the console.

const args = process.argv.slice(2); // Remove the first two elements

const operation = args[0]; // Operation: "add", "subtract", "multiply", "divide"
const num1 = parseFloat(args[1]); // First number
const num2 = parseFloat(args[2]); // Second number

let result;

switch (operation) {
  case 'add':
    result = num1 + num2;
    break;
  case 'subtract':
    result = num1 - num2;
    break;
  case 'multiply':
    result = num1 * num2;
    break;
  case 'divide':
    result = num1 / num2;
    break;
  default:
    console.log('Unknown operation. Use "add", "subtract", "multiply", or "divide".');
    process.exit(1); // Exit the program with an error code
}

console.log(`Result: ${result}`);

My Experience

After running the program with the command node calculator.js multiply 7 3, I received the result Result: 21, which confirmed that my code was correct.

Conclusion

This experience showed me how easy it is to work with the console in Node.js. I learned how to pass command line arguments, use them in a program, and output results to the console. This lesson strengthened my knowledge and provided practical skills that will be useful as I continue learning Node.js.

All lessons created by ChatGPT are published here: https://king-tri-ton.github.io/learn-nodejs/.

Learning Node.js in 30 Days with AI - Day 2

King Triton — Mon, 26 Aug 2024 05:03:51 +0000

Today, I continued my Node.js learning journey with the help of AI, and the topic for Day 2 was the module system in Node.js. Since I'm already familiar with JavaScript, it was interesting to learn how this language organizes code into modules, making it easier to structure and reuse.

Theoretical Part: Basics of Modules in Node.js

First, I went through the theoretical part, which explained two key concepts:

require: This function is used to import modules into your code. When you call require('module_name'), Node.js finds the specified module and returns its content. This can be a built-in module, a module from the node_modules package, or your own custom module.
module.exports: This object is used to export functionality from a module so that it can be used by other modules via require. You can export functions, objects, variables, or classes.

These concepts were new to me in the context of Node.js, but similar to what I’ve seen in other programming languages.

Practical Application: Creating Modules

I started by creating several modules for different mathematical operations, as suggested in the article.

addition.js: This module performs addition.

function add(a, b) {
    return a + b;
}

module.exports = add;

subtraction.js: A module for subtraction.

function subtract(a, b) {
    return a - b;
}

module.exports = subtract;

multiplication.js: A module for multiplication.

function multiply(a, b) {
    return a * b;
}

module.exports = multiply;

division.js: A module for division.

function divide(a, b) {
    if (b === 0) {
        return 'Error: Division by zero';
    }
    return a / b;
}

module.exports = divide;

After creating these modules, I started writing the main file that would use them.

calculator.js: In this file, I imported all the modules I created and wrote code to perform arithmetic operations.

const add = require('./addition');
const subtract = require('./subtraction');
const multiply = require('./multiplication');
const divide = require('./division');

console.log("Addition: 5 + 3 =", add(5, 3));
console.log("Subtraction: 5 - 3 =", subtract(5, 3));
console.log("Multiplication: 5 * 3 =", multiply(5, 3));
console.log("Division: 6 / 2 =", divide(6, 2));

Expanding the Functionality

After completing the basic operations, I decided to challenge myself by adding new functions to the calculator. I created additional modules for exponentiation and square root:

exponentiation.js: A module for exponentiation.

function exponentiate(base, exponent) {
    return Math.pow(base, exponent);
}

module.exports = exponentiate;

sqrt.js: A module for calculating the square root.

function sqrt(number) {
    return Math.sqrt(number);
}

module.exports = sqrt;

I added these to the main file calculator.js, and now my calculator supported extended operations:

const add = require('./addition');
const subtract = require('./subtraction');
const multiply = require('./multiplication');
const divide = require('./division');
const exponentiate = require('./exponentiation');
const sqrt = require('./sqrt');

console.log("Addition: 5 + 3 =", add(5, 3));
console.log("Subtraction: 5 - 3 =", subtract(5, 3));
console.log("Multiplication: 5 * 3 =", multiply(5, 3));
console.log("Division: 6 / 2 =", divide(6, 2));
console.log("Exponentiation: 2 ^ 3 =", exponentiate(2, 3));
console.log("Square root of 16 =", sqrt(16));

Results and Conclusions

By applying the theory in practice, I gained a better understanding of how modules help organize code and how easy they are to use in Node.js. Working with separate files for each operation made me realize the importance of modularity and how it improves code readability and scalability.

This experience showed me how crucial it is to organize code properly, especially as a project becomes more complex. Now I feel confident working with modules in Node.js and am ready for the next step in my learning journey.

For more details on this lesson, you can refer to the full tutorial here.

This is how I learned from the article and understood how modules work in Node.js through practical application.

Integrating Telegram Stars ⭐️ Payment in a Python Bot

King Triton — Sun, 25 Aug 2024 14:37:57 +0000

Today I'll show you how to set up payments in your bot using Telegram's internal currency, Telegram Stars ⭐️.

Step 1: Create a Bot

First, create a bot using BotFather. If you're familiar with this process, you can use your own test bot. In this example, I'll use the bot @repeats_bot.

Step 2: Prepare the Project Structure

Here’s an example of your project structure:



TelegramStarsBot (root)

|-img/

  |-img-X9ptcIuiOMICY0BUQukCpVYS.png

|-bot.py

|-config.py

|-database.py

|-.env

Step 3: Bot Code

`bot.py`



import telebot

from telebot import types

from config import TOKEN

from database import init_db, save_payment

import os

bot = telebot.TeleBot(TOKEN)

# Initialize the database

init_db()

# Function to create a payment keyboard

def payment_keyboard():

    keyboard = types.InlineKeyboardMarkup()

    button = types.InlineKeyboardButton(text="Pay 1 XTR", pay=True)

    keyboard.add(button)

    return keyboard

# Function to create a keyboard with the "Buy Image" button

def start_keyboard():

    keyboard = types.InlineKeyboardMarkup()

    button = types.InlineKeyboardButton(text="Buy Image", callback_data="buy_image")

    keyboard.add(button)

    return keyboard

# /start command handler

@bot.message_handler(commands=['start'])

def handle_start(message):

    bot.send_message(

        message.chat.id,

        "Welcome! Click the button below to buy an image.",

        reply_markup=start_keyboard()

    )

# Handler for the "Buy Image" button press

@bot.callback_query_handler(func=lambda call: call.data == "buy_image")

def handle_buy_image(call):

    prices = [types.LabeledPrice(label="XTR", amount=1)]  # 1 XTR

    bot.send_invoice(

        call.message.chat.id,

        title="Image Purchase",

        description="Purchase an image for 1 star!",

        invoice_payload="image_purchase_payload",

        provider_token="",  # For XTR, this token can be empty

        currency="XTR",

        prices=prices,

        reply_markup=payment_keyboard()

    )

# Handler for pre-checkout queries

@bot.pre_checkout_query_handler(func=lambda query: True)

def handle_pre_checkout_query(pre_checkout_query):

    bot.answer_pre_checkout_query(pre_checkout_query.id, ok=True)

# Handler for successful payments

@bot.message_handler(content_types=['successful_payment'])

def handle_successful_payment(message):

    user_id = message.from_user.id

    payment_id = message.successful_payment.provider_payment_charge_id

    amount = message.successful_payment.total_amount

    currency = message.successful_payment.currency

<span class="c1"># Send a purchase confirmation message



    bot.send_message(message.chat.id, "✅ Payment accepted, please wait for the photo. It will arrive soon!")

<span class="c1"># Save payment information to the database



    save_payment(user_id, payment_id, amount, currency)

<span class="c1"># Send the image



    photo_path = 'img/img-X9ptcIuiOMICY0BUQukCpVYS.png'

    if os.path.exists(photo_path):

        with open(photo_path, 'rb') as photo:

            bot.send_photo(message.chat.id, photo, caption="🥳Thank you for your purchase!🤗")

    else:

        bot.send_message(message.chat.id, "Sorry, the image was not found.")

# /paysupport command handler

@bot.message_handler(commands=['paysupport'])

def handle_pay_support(message):

    bot.send_message(

        message.chat.id,

        "Purchasing an image does not imply a refund. "

        "If you have any questions, please contact us."

    )

# Start polling

bot.polling()

`config.py`



import os

from dotenv import load_dotenv

# Load environment variables from .env file

load_dotenv()

# Get values from environment variables

TOKEN = os.getenv('TOKEN')

DATABASE = os.getenv('DATABASE')

`database.py`



import sqlite3

from config import DATABASE

def init_db():

    with sqlite3.connect(DATABASE) as conn:

        cursor = conn.cursor()

        cursor.execute('''

            CREATE TABLE IF NOT EXISTS payments (

                user_id INTEGER,

                payment_id TEXT,

                amount INTEGER,

                currency TEXT,

                PRIMARY KEY (user_id, payment_id)

            )

        ''')

        conn.commit()

def save_payment(user_id, payment_id, amount, currency):

    with sqlite3.connect(DATABASE) as conn:

        cursor = conn.cursor()

        cursor.execute('''

            INSERT INTO payments (user_id, payment_id, amount, currency)

            VALUES (?, ?, ?, ?)

        ''', (user_id, payment_id, amount, currency))

        conn.commit()

Code Explanation

Payments with Telegram Stars

payment_keyboard and start_keyboard create buttons for user interaction. The first button allows payment, and the second initiates the image purchase.
handle_buy_image creates and sends an invoice for payment using the XTR currency. Here, provider_token can be empty as XTR does not require a token.
handle_pre_checkout_query and handle_successful_payment handle the payment verification and confirmation process.
Upon successful payment, the bot sends the image to the user and saves the payment information in the database.

Working with the Database

init_db creates the payments table if it does not exist. This table stores information about the user, payment, amount, and currency.
save_payment saves payment information to the database. This is necessary for potential refunds and transaction reports.

Important Notes

Bot Owner Payment: If the bot owner tries to make a purchase within the bot, the purchase will not be completed. This prevents fraud or erroneous purchases made by the administrator.
Managing Stars: Stars are stored within the Telegram bot. To view the balance, go to the bot settings in Telegram, select "Manage Bot," and click "Balance." Here, you can view and manage earned stars, withdraw them, or spend them on advertising.

Conclusion

Your bot is now set up to accept payments via Telegram Stars and send an image after a successful purchase. Make sure all settings and data in the configuration files are correct.

I’d appreciate it if you leave a reaction or comment! You can also find the complete source code on GitHub.

Learning Node.js in 30 Days with AI - Day 1

King Triton — Sun, 25 Aug 2024 05:19:00 +0000

Learning Goal

My main goal is to learn Node.js in 30 days using AI, specifically with the help of ChatGPT. Since I’m already familiar with JavaScript, I asked ChatGPT to create a study plan tailored to my existing knowledge.

Planning

23.08.2024: I created a learning plan with the help of ChatGPT.
24.08.2024: I organized the plan into a Google Document for convenience. You can view the plan here.

Day 1: Introduction to Node.js

Theory

What is Node.js?

Node.js is a platform for executing JavaScript on the server side. It allows running JavaScript code outside of a browser, using Google’s V8 engine. Node.js is designed for building scalable network applications, such as web servers and APIs.
How does Node.js work?

Node.js uses a non-blocking, asynchronous I/O model, which means that I/O operations (e.g., reading files or database queries) are performed asynchronously without blocking the main execution thread. The main components of Node.js include:
- Event Loop: Manages the execution of asynchronous operations and invokes the corresponding callback functions.
- Non-blocking I/O: I/O operations are performed in the background, allowing the main thread to continue working.
- Single-threaded Model: Although the execution thread is single, thanks to asynchrony and the event loop, Node.js can handle multiple operations concurrently.
Key Features of Node.js:
- Asynchronous and non-blocking model.
- Event loop for managing asynchronous operations.
- Modular system with CommonJS modules.
- NPM (Node Package Manager).
- High performance due to the V8 engine and asynchronous model.

Practice

Task 1: Installing and Setting Up Node.js

I installed Node.js from the official website, selecting the latest LTS version and following the installer instructions. After installation, I verified the Node.js and npm versions in the command line using the commands node -v and npm -v.

Task 2: Setting Up the Development Environment

I created a new project, initialized it with npm (npm init -y), and installed the Express package (npm install express).

Task 3: Creating a Simple Program

I created an index.js file where I wrote code for a simple web server using Express. I started the server with the command node index.js and tested it by opening http://localhost:3000 in the browser, where I saw the message "Hello World!".

Day 1 Summary

All the tasks for the first day were successfully completed. I have documented the first day's progress on my website here, where I also added visual aids to enhance understanding.

Call to Action

I’d love to hear your thoughts and feedback! Please leave your comments and reactions, and share your own experiences with learning Node.js. Together, we can achieve even greater success!

Build your own LinkTree (Taplink) with Python and GitHub Pages

King Triton — Fri, 23 Aug 2024 13:58:30 +0000

How to Create Your Own LinkTree with Python and GitHub Pages

I stumbled upon an article by Lucas Neves Pereira titled "Build your own LinkTree with Go and GitHub Pages". The article describes how to create a LinkTree-like page (Taplink) using Go. As a Python enthusiast, I decided to implement the project in Python. Here’s what I came up with.

Step 1: Preparing the Project File Structure

First, let's create the file structure for our project. We’ll organize it to be easily maintainable and deployable on GitHub Pages.

File Structure:

/ (root)
|-- /docs
|   |-- index.html
|   |-- /assets
|       |-- (styles, scripts, icons, etc.)
|-- config.yml
|-- generate_site.py
|-- /themes

/docs: This folder will hold the generated HTML files and all necessary assets (images, styles, scripts). This folder will be used for deployment on GitHub Pages.
config.yml: Configuration file containing all data for personalizing the site.
generate_site.py: Python script that will generate the site based on data from config.yml.
/themes: Folder containing themes for the site. In our case, it has a single custom theme that includes HTML templates, styles, scripts, and images.

Step 2: Configuring the Configuration File (`config.yml`)

The config.yml file contains user data and links that will be displayed on the site. Here’s its content:

name: "King Triton"
picture: "assets/img/picture.jpg"
bio: "Programmer python and php/laravel"
meta:
  lang: "en"
  description: "Programmer python and php/laravel"
  title: "King Triton"
  author: "King Triton"
  siteUrl: "https://king-tri-ton.github.io"
links:
  - name: "Github"
    url: "https://github.com/king-tri-ton"
  - name: "Dev.to"
    url: "https://dev.to/king_triton"
  - name: "Patreon"
    url: "https://www.patreon.com/king_triton"
  - name: "Telegram"
    url: "https://t.me/king_triton"
  - name: "Instagram"
    url: "https://www.instagram.com/king_tri_ton"
theme: "custom"

name: The user’s name that will be displayed on the site.
picture: Path to the user’s image.
bio: A brief biography of the user.
meta: Site metadata (language, description, title, author, site URL).
links: List of links to be displayed on the site. Each item includes a name and URL.
theme: The site theme to use.

Step 3: Developing the Python Script to Generate the Site (`generate_site.py`)

Next, we’ll write a Python script that will use the theme template, data from config.yml, and generate the HTML file.

import os
import shutil
from jinja2 import Environment, FileSystemLoader
import yaml

# Load configuration
with open('config.yml', 'r') as config_file:
    config = yaml.safe_load(config_file)

# Create output directory
output_dir = 'docs'
os.makedirs(output_dir, exist_ok=True)

# Set up Jinja2
env = Environment(loader=FileSystemLoader('themes/custom'))
template = env.get_template('index.html')

# Generate HTML file
output_html = template.render(config=config)
with open(os.path.join(output_dir, 'index.html'), 'w') as fh:
    fh.write(output_html)

# Copy assets folder to output directory
assets_source = os.path.join('themes', config['theme'], 'assets')
assets_dest = os.path.join(output_dir, 'assets')
if os.path.exists(assets_source):
    shutil.copytree(assets_source, assets_dest, dirs_exist_ok=True)

print("Site generated successfully.")

Loading configuration: The script loads data from config.yml.
Creating output directory: The docs folder is created automatically if it doesn’t exist.
Setting up Jinja2: Jinja2 is used to load the HTML template and render the content.
Generating HTML file: The script generates index.html using the configuration data and saves it in the docs folder.
Copying assets: All assets (CSS, images, scripts) are copied to the docs/assets folder.

Step 4: Creating the Theme and Assets

Now, create the theme that will be used for the site. In the themes/custom/ folder, there should be the following files:

`themes/custom/index.html`

This is the main HTML template for the site, using variables from the configuration file.

<!DOCTYPE html>
<html lang="{{ config.meta.lang }}">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta name="description" content="{{ config.meta.description }}">
    <title>{{ config.meta.title }}</title>
    <meta name="author" content="{{ config.meta.author }}">
    <link rel="canonical" href="{{ config.meta.siteUrl }}">
    <link rel="icon" type="image/x-icon" href="assets/icons/favicon.ico">
    <link rel="stylesheet" href="assets/css/styles.css">
    <meta property="og:title" content="{{ config.meta.title }}">
    <meta property="og:site_name" content="{{ config.meta.title }}">
    <meta property="og:description" content="{{ config.meta.description }}">
    <meta property="og:locale" content="{{ config.meta.lang }}">
    <meta name="twitter:title" content="{{ config.meta.title }}">
    <meta name="twitter:description" content="{{ config.meta.description }}">
</head>
<body>
    <header>
        <img src="{{ config.picture }}" alt="Picture" class="avatar">
        <h1>{{ config.name }}</h1>
        <small class="bio">{{ config.bio }}</small>
    </header>
    <main>
        <section class="links">
            {% for link in config.links %}
            <a class="link-item" href="{{ link.url }}" target="_blank" rel="noopener noreferrer">
                <p>{{ link.name }}</p>
            </a>
            {% endfor %}
        </section>
    </main>
    <footer>
        <small>© <span class="year"></span> {{ config.meta.author }}</small>
    </footer>
    <script src="assets/js/script.js"></script>
</body>
</html>

`themes/custom/assets/styles.css`

CSS file for styling the page.

/* CSS Reset */
* {
  margin: 0;
  padding: 0;
  box-sizing: border-box;
}

/* Variables */
:root {
  --max-width: 600px;
  --font-family: 'Inter', sans-serif;
  --padding: 1rem;
  --header-margin-bottom: 1rem;
  --line-height: 2;
  --font-size: 16px;

  --primary-color-light: #ffffff;
  --background-color-light: #f0f0f0;
  --text-color-light: #333;
  --link-color-light: #1a73e8;
  --bio-color-light: #666;

  --primary-color-dark: #1e1e1e;
  --background-color-dark: #121212;
  --text-color-dark: #e0e0e0;
  --link-color-dark: #8ab4f8;
  --bio-color-dark: #aaa;
}

/* Light Theme */
@media (prefers-color-scheme: light) {
  :root {
    --primary-color: var(--primary-color-light);
    --background-color: var(--background-color-light);
    --text-color: var(--text-color-light);
    --link-color: var(--link-color-light);
    --bio-color: var(--bio-color-light);
  }
}

/* Dark Theme */
@media (prefers-color-scheme: dark) {
  :root {
    --primary-color: var(--primary-color-dark);
    --background-color: var(--background-color-dark);
    --text-color: var(--text-color-dark);
    --link-color: var(--link-color-dark);
    --bio-color: var(--bio-color-dark);
  }
}

/* Global Styles */
html {
  font-family: var(--font-family);
  font-size: var(--font-size);
  line-height: var(--line-height);
}

body {
  max-width: var(--max-width);
  min-height: 100vh;
  margin: 0 auto;
  display: flex;
  flex-direction: column;
  align-items: center;
  background-color: var(--background-color);
  color: var(--text-color);
  padding: var(--padding);
}

/* Header Styles */
header {
  padding: var(--padding) 0;
  margin-bottom: var(--header-margin-bottom);
  width: 100%;
  display: flex;
  flex-direction: column;
  justify-content: center;
  align-items: center;
  text-align: center;
}

.avatar {
  width: 100px;
  height: 100px;
  border-radius: 50%;
  object-fit: cover;
  border: 2px solid var(--primary-color);
  box-shadow: 0 4px 8px rgba(0, 0, 0, 0.1);
}

h1 {
  font-size: 24px;
  margin-bottom: 0.5rem;
}

.bio {
  font-size: 14px;
  color: var(--bio-color);
  margin-bottom: 1rem;
}

/* Main Content Styles */
main {
  width: 100%;
  flex: 1;
}

.links {
  display: flex;
  flex-direction: column;
  gap: 1rem;
  text-align: center;
  overflow-y: auto;
  max-height: 400px;
}

.link-item {
  display: block;
  padding: 16px 20px;
  text-decoration: none;
  color: var(--link-color);
  background: var(--primary-color);
  border-radius: 12px;
  border: 1px solid var(--link-color);
  transition: background-color 0.25s, color 0.25s;
}

.link-item:hover,
.link-item:focus {
  background-color: var(--link-color);
  color: var(--primary-color);
}

.link-item p {
  line-height: 1.5;
  font-weight: 500;
}

/* Footer Styles */
footer {
  width: 100%;
  text-align: center;
  padding: 1rem 0;
  font-size: 14px;
  gap: 1rem;
  display: flex;
  justify-content: center;
  align-items: center;
}

/* ScrollBar */
::-webkit-scrollbar {
  width: 5px;
}

::-webkit-scrollbar-track {
  background: transparent;
}

::-webkit-scrollbar-thumb {
  background: transparent;
}

::-webkit-scrollbar-thumb:hover {
  background: transparent;
}

`themes/custom/assets/js/script.js`

JavaScript file for basic functionalities.

console.log("scripts loaded");

const yearDate = new Date().getFullYear().toString();
document.querySelector(".year").innerText = yearDate;

`themes/custom/assets/img/picture.jpg`

The photo used as the avatar.

Step 5: Generating the Site

After creating all the files, run the generate_site.py script to generate the site:

python generate_site.py

The site will be generated in the docs folder.

Step 6: Deploying on GitHub Pages

Create a new repository on GitHub.
Upload all files, including the docs folder, to the repository.
Go to the repository’s Settings section.
In the Pages section, select the master branch and the /docs folder as the source.
Save changes and wait for GitHub Pages to deploy your site.

Your site will now be available at https://<username>.github.io/<repository-name>/.

And that’s it! You now have your own LinkTree-style site created with Python and deployed on GitHub Pages. You can check the final result at https://king-tri-ton.github.io/pythonpagelink/.

10 Tips for Efficiently Using Python in Web Development

King Triton — Fri, 23 Aug 2024 09:23:13 +0000

Python is one of the most popular programming languages, and its use in web development is increasingly relevant. In this article, we'll explore 10 useful tips for making the most of Python in your web projects.

1. Use Frameworks to Speed Up Development

Frameworks like Django and Flask greatly simplify web application development. Django offers many built-in features for creating scalable and secure applications, while Flask provides a more flexible approach for smaller projects and microservices.

2. Follow the MVC Pattern

When developing web applications, adhere to the MVC (Model-View-Controller) architectural pattern. This helps structure your code, makes it more readable, and simplifies testing.

3. Use Virtual Environments

Employ virtual environments to manage project dependencies. This isolates libraries and their versions, making your project more stable and preventing conflicts.

python -m venv myenv
source myenv/bin/activate  # For Unix
myenv\Scripts\activate     # For Windows

4. Pay Attention to Security

Security is a critical aspect of web development. Use well-vetted libraries and frameworks to prevent vulnerabilities. For Django, utilize built-in features to protect against SQL injections, CSRF attacks, and XSS.

5. Write Tests

Write tests for your code to ensure that your application behaves as expected. Use testing frameworks such as pytest, unittest, or Django’s testing module.

6. Leverage Asynchronous Programming

If your application demands high performance and scalability, consider using asynchronous programming with the asyncio library or the FastAPI framework. This helps handle requests more efficiently.

7. Optimize Database Queries

Inefficient database queries can slow down your application. Use profiling tools and query optimization techniques. In Django, you can use built-in tools to analyze SQL queries.

8. Use Task Managers

For background tasks and handling long operations, use task managers like Celery. This helps break work into smaller tasks that can be executed asynchronously.

9. Document Your Code

Document your code and API so other developers can easily understand your work. Use tools like Sphinx to generate documentation from your docstrings.

10. Monitor Performance

Use profilers and monitoring tools to track your application’s performance. This helps identify bottlenecks and optimize your code.

Conclusion

These tips will help you make Python development more efficient and productive. By following them, you'll be able to create high-quality web applications that are easy to scale and maintain. Happy coding!

DEV Community: King Triton

Telegram Bot @ChatGPTTlgrmBot Updated to GPT-5.1: New Features and Promo Code

How to Use the Bot

Why I Did This

Open Source Code

Try It Out

Building a GPT-5 Telegram Bot with Telegram Stars Monetization

Introduction

💡 The Idea

🛠 Tech Stack

Core Technologies

Why These Technologies?

📐 Architecture Overview

🔧 Implementation

1. Project Structure

2. Database Schema

3. OpenAI Integration

4. Telegram Bot Core

5. Telegram Stars Payment Integration

6. Message Processing

🎯 Key Features Implemented

1. Flexible Payment System

2. User Experience

3. Admin Dashboard

📊 Performance & Scalability

Current Setup

Scaling Considerations

💰 Cost Analysis

Running Costs

Pricing Strategy

🔒 Security Best Practices

🚀 Deployment

Quick Deploy Script

Using systemd (Linux)

📈 Future Improvements

🎓 Lessons Learned

🤝 Contributing

📚 Resources

🎉 Conclusion

python #telegram #openai #gpt5 #bot #monetization #telegramstars #ai #chatbot #opensource

Learning Node.js in 30 Days with AI - Day 6

Theory Recap

Practical Task

Independent Task

Conclusion

Resources

Learning Node.js in 30 Days with AI - Day 5

Diving into File Operations and Streams

Understanding the fs Module

Streams: Handling Data Efficiently

Independent Task: Putting It All Together

Conclusion

Resources

Learning Node.js in 30 Days with AI - Day 4

Help Needed with Creating a Console Bot Using OpenAI Assistants API

Learning Node.js in 30 Days with AI - Day 3

What I Learned

Practical Task

My Experience

Conclusion

Learning Node.js in 30 Days with AI - Day 2

Theoretical Part: Basics of Modules in Node.js

Practical Application: Creating Modules

Expanding the Functionality

Results and Conclusions

Integrating Telegram Stars ⭐️ Payment in a Python Bot

Step 1: Create a Bot

Step 2: Prepare the Project Structure

Step 3: Bot Code

bot.py

config.py

database.py

Code Explanation

Payments with Telegram Stars

Working with the Database

Important Notes

Conclusion

Learning Node.js in 30 Days with AI - Day 1

Learning Goal

Planning

Understanding the `fs` Module

`bot.py`

`config.py`

`database.py`

Step 2: Configuring the Configuration File (`config.yml`)

Step 3: Developing the Python Script to Generate the Site (`generate_site.py`)

`themes/custom/index.html`

`themes/custom/assets/styles.css`

`themes/custom/assets/js/script.js`

`themes/custom/assets/img/picture.jpg`