News : PySimpleGUI planned shutdown

The PySimpleGUI project’s planned shutdown was first announced in February 2025. At that time, we committed to supporting our Commercial customers through the end of 2025. PySimpleGUI 5 remained a very stable product throughout the year, with no significant issues reported.

Now that we’ve reached the end of that support period, the project is entering its final stage. During January 2026, the PySimpleGUI website, documentation, and PyPI servers will be taken offline as we officially close the project.

The private PyPI server will be shut down in January 2026 . If you currently install PySimpleGUI 5 using pip, you’ll need to switch to installing from a local wheel file instead.

Tools : Pickcode online I.D.E.

Pickcode is an online IDE, similar to Trinket. With a free account, you can create unlimited projects in Python, Java, and HTML/CSS/JS.

With our paid Pickcode Classroom plan, teachers can create lessons, set up classes and assignments, and view student work in real time.

Pickcode Classroom costs $500/teacher plus $10/student per year. We are considering options for adding a lower-priced plan similar to Trinket’s Code+, and will have more info about that later this year.

See more on the official website.

News : Trinket will be shutting down in early August 2026.

We are deeply grateful for your support over the years. Trinket has been used by millions of learners and educators, and it has been an honor to be part of your coding journey.

We're truly sorry for any disruption this may cause. If you have questions, please reach out to us at help@trinket.io.

If you have an annual subscription, you'll continue to have full access until the end of your current paid period. Your subscription will not renew.

Monthly subscriptions will not renew after June 30, 2026.

Trinket will be shutting down in early August 2026.

After this date, trinket.io will no longer be available, and you will not be able to access your trinkets, courses, or any content on this site. Please download anything you want to keep before the shutdown.

Python Qt6 : using the py3Dmol .

NOTE : hacker provider ... :

Simple example with the py3Dmol:

import os
import sys

from PyQt6.QtWidgets import QApplication, QWidget, QVBoxLayout
from PyQt6.QtWebEngineWidgets import QWebEngineView
from PyQt6.QtCore import QUrl
import py3Dmol

SEROTONIN_SMILES = "C1=CC2=C(C=C1)C(=CN2)CCN"

def generate_html(smiles):
    view = py3Dmol.view(width=800, height=600)
    view.addModel(smiles, "smiles")
    view.setStyle({"stick": {}})
    view.zoomTo()
    return view._make_html()

class MoleculeViewer(QWidget):
    def __init__(self):
        super().__init__()
        self.setWindowTitle("Structura 3D – Serotonină")

        layout = QVBoxLayout(self)
        self.browser = QWebEngineView()

        html = generate_html(SEROTONIN_SMILES)

        # IMPORTANT: QUrl, nu string!
        self.browser.setHtml(html, baseUrl=QUrl("https://localhost/"))

        layout.addWidget(self.browser)

if __name__ == "__main__":
    app = QApplication(sys.argv)
    window = MoleculeViewer()
    window.resize(900, 700)
    window.show()
    sys.exit(app.exec())

Python Qt6 : remove files by size.

After the vendor hacker changed my file sizes to 0kb and 1kb, only from the folders on my laptop and backup on the backup hdd, for the development project with the game I was working on with artificial intelligence. I created a script in Python to see if he left anything in the folders and subfolders.

Python Qt6 : one simple markdown editor.

Today, I tested my simple Markdown editor. I used artificial intelligence.

This project is a custom Markdown editor built with PyQt6.

It provides a two‑panel interface where the user writes Markdown on the right side and sees a live HTML preview on the left side.

The goal is to offer a simple and efficient workflow similar to GitHub’s Markdown rendering.

Main Features

• Two‑panel layout The left panel displays the rendered HTML preview, while the right panel contains the Markdown editor and formatting buttons.
• Real‑time preview Every change in the editor updates the preview instantly. The preview uses multiple Markdown extensions to support tables, lists, code blocks, footnotes, and other GitHub‑style formatting.
• Image support Images inserted through the editor are converted to local file URLs. This ensures that the preview panel can load them correctly, even when the image is stored outside the project folder.
• Markdown extensions The editor enables a wide set of extensions, including:

  • tables
  • fenced code blocks
  • footnotes
  • definition lists
  • smart quotes
  • wiki links
  • admonitions
  • GitHub‑style lists

  These extensions allow the preview to closely match GitHub’s Markdown rendering.
• Editing toolbar The editor includes quick‑insert buttons for bold, italic, lists, and images. These buttons modify only the Markdown text in the editor panel.
• Zoom controls The preview panel includes buttons for resetting zoom to 100 percent, zooming in, and zooming out. This helps when working with long documents or detailed tables.
• File operations The application supports creating, opening, and saving Markdown files. It also includes an option to export the rendered content as an HTML file.
• Theme switching Users can switch between light and dark themes depending on their preference.
• Drag and drop Markdown files can be opened by dragging them directly into the window.
• Plugin system The editor includes a simple plugin mechanism that allows adding new features without modifying the core application.
• Status bar The bottom bar displays the current file path, file size, and word count.

Python 3.13.0 : New Feature: Interactive History Search.

If you are using the new Python 3.13 REPL, you might have noticed a new prompt when pressing certain keys. This is the upgraded interactive shell that now supports built-in history searching.

What is f-search and r-search?

These features allow you to search through every command you have previously typed without using the arrow keys.

How to trigger it:

- Press Ctrl + R to initiate a Reverse Search. You will see (r-search ''). This looks through your history from newest to oldest.

- Press Ctrl + S to initiate a Forward Search. You will see (f-search ''). This looks through your history from oldest to newest.

How to use it:

1. Type the shortcut (Ctrl+R or Ctrl+S).

2. Start typing any part of a previous command (e.g., 'import' or 'def').

3. The shell will automatically complete the line with the best match.

4. Press Enter to run the command, or use the arrow keys to start editing the found line.

5. If you want to cancel the search, simply press Ctrl + G.

This feature makes the Python 3.13 terminal feel much more like a modern shell, saving time and reducing repetitive typing.

C:\Python313_64bit>python
Python 3.13.0 (tags/v3.13.0:60403a5, Oct  7 2024, 09:38:07) [MSC v.1941 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> import os
>>> import sys
(r-search `os') import os

Python 3.13.0 : Motion extraction from video with python programming.

... based on this video - Motion Extraction with python source code.

• 1. Temporal Displacement
  Let V(t) represent the video frame at the current time t.
  A secondary reference frame is generated at time t + Δt, where Δt is the defined time delay (shift).
• 2. Absolute Difference Calculation
  For every pixel coordinate (x, y), the algorithm calculates the absolute difference between the two points in time:
  D(x,y) = | V(x,y,t) - V(x,y,t + Δt) |
• 3. Result Interpretation
  • Static Areas: If the pixel value remains constant, the result is 0 (Black).
  • Motion: If the pixel value changes, the result is a positive integer > 0 (the "ghosting" trail).
• 4. Signal Amplification (Contrast)
  The raw difference values are multiplied by a constant factor k to make faint motion visible:
  Output(x,y) = D(x,y) × k

News : examples with rich python package.

Python's Rich package is a tool kit that helps you generate beautifully formatted and highlighted text in the console.

Let's see some examples:

Run the source code with these args --demo and --dashboard:

import time
import sys
import logging
import argparse
import msvcrt  # Windows keyboard input

from rich.console import Console
from rich.table import Table
from rich.panel import Panel
from rich.progress import Progress, SpinnerColumn, BarColumn, TextColumn
from rich.syntax import Syntax
from rich.layout import Layout
from rich.live import Live
from rich.theme import Theme
from rich.logging import RichHandler

# ---------------------------------------------------------
# 1. DARK THEME
# ---------------------------------------------------------
dark_theme = Theme({
    "info": "bold cyan",
    "warning": "bold yellow",
    "error": "bold red",
    "success": "bold green",
    "title": "bold magenta",
    "data": "bold white",
})

console = Console(theme=dark_theme)

# ---------------------------------------------------------
# 2. LOGGING (RichHandler)
# ---------------------------------------------------------
logging.basicConfig(
    level="INFO",
    format="%(message)s",
    datefmt="[%H:%M:%S]",
    handlers=[RichHandler(console=console)]
)
log = logging.getLogger("CLI")

# ---------------------------------------------------------
# 3. CLI ARGUMENTS
# ---------------------------------------------------------
def parse_args():
    parser = argparse.ArgumentParser(
        description="Rich CLI + Dashboard + Menu + Buttons"
    )
    parser.add_argument("--demo", action="store_true", help="Run the demo")
    parser.add_argument("--dashboard", action="store_true", help="Start the dashboard")
    return parser.parse_args()

# ---------------------------------------------------------
# 4. WINDOWS KEY READER
# ---------------------------------------------------------
def get_key():
    if msvcrt.kbhit():
        return msvcrt.getch().decode(errors="ignore")
    return None

# ---------------------------------------------------------
# 5. MENU + BUTTONS
# ---------------------------------------------------------
menu_items = ["Statistics", "Processes", "Settings", "Exit"]
selected = 0

def render_menu():
    table = Table(show_header=False, expand=True)
    for i, item in enumerate(menu_items):
        if i == selected:
            table.add_row(f"[black on cyan] {item} [/]")
        else:
            table.add_row(f"[cyan] {item} [/]")
    return Panel(table, title="Menu", border_style="cyan")

def render_content():
    if menu_items[selected] == "Statistics":
        return Panel("CPU: 37%\nRAM: 62%\nDisk: 128MB/s", title="System Statistics")

    elif menu_items[selected] == "Processes":
        return Panel("proc1\nproc2\nproc3", title="Running Processes")

    elif menu_items[selected] == "Settings":
        return Panel("Settings will appear here", title="Settings")

    elif menu_items[selected] == "Exit":
        return Panel("[red]Press ENTER to exit[/red]", title="Exit")

# ---------------------------------------------------------
# 6. DASHBOARD LAYOUT (original + menu added)
# ---------------------------------------------------------
def build_dashboard():
    layout = Layout()

    layout.split(
        Layout(name="header", size=3),
        Layout(name="body", ratio=1),
        Layout(name="footer", size=3),
    )

    layout["body"].split_row(
        Layout(name="left", size=30),
        Layout(name="right")
    )

    layout["header"].update(
        Panel("[title]LIVE DASHBOARD — Rich Dark Mode[/title]", style="bold magenta")
    )

    layout["left"].update(render_menu())
    layout["right"].update(render_content())

    layout["footer"].update(
        Panel("[info]Status: Running in real time[/info]")
    )

    return layout

# ---------------------------------------------------------
# 7. DEMO (unchanged from first script)
# ---------------------------------------------------------
def run_demo():
    console.print("[success]Rich Dark Mode Demo Started[/success]")

    table = Table(title="Example Table", expand=True)
    table.add_column("ID", style="yellow")
    table.add_column("Name", style="cyan")
    table.add_column("Status", style="green")

    table.add_row("1", "Catalin", "Active")
    table.add_row("2", "Rich CLI", "OK")
    table.add_row("3", "Dashboard", "Ready")

    console.print(table)

    log.info("This is an INFO message")
    log.warning("This is a WARNING message")
    log.error("This is an ERROR message")

    with Progress(
        SpinnerColumn(),
        BarColumn(),
        TextColumn("[progress.percentage]{task.percentage:>3.0f}%"),
        console=console,
    ) as progress:
        task = progress.add_task("Processing...", total=100)
        for _ in range(100):
            time.sleep(0.02)
            progress.update(task, advance=1)

    code = """
def greet(name):
    return f"Hello, {name}!"

print(greet("Catalin"))
"""
    syntax = Syntax(code, "python", theme="monokai", line_numbers=True)
    console.print(Panel(syntax, title="Syntax Highlight"))

# ---------------------------------------------------------
# 8. MAIN LOOP
# ---------------------------------------------------------
if __name__ == "__main__":
    args = parse_args()

    if args.demo:
        run_demo()

    if args.dashboard:
        with Live(build_dashboard(), refresh_per_second=10) as live:
            while True:
                key = get_key()

                if key == "w":
                    selected = (selected - 1) % len(menu_items)
                elif key == "s":
                    selected = (selected + 1) % len(menu_items)
                elif key == "\r":
                    if menu_items[selected] == "Exit":
                        break

                live.update(build_dashboard())

Python 3.13.0 : ... build full-stack web applications entirely in Python with reflex.

NOTE : Yesterday I tested this framework and it blocked my python running and I couldn't display the result. Interesting about this framework is that you can also program your backend running.

The static motion is green because is not used with RGB colors.

Reflex is a library to build full-stack web apps in pure Python.

Reflex is a Python library designed to build full-stack web applications entirely in Python, eliminating the need to learn JavaScript. It allows developers to create both the frontend and backend of web applications seamlessly, offering flexibility and scalability for projects ranging from simple prototypes to complex systems.

See the GitHub project page.

See my test on Winodws O.S. :

mkdir my_app_catafest

cd my_app_catafest

my_app_catafest>python -m venv .venv

my_app_catafest>.venv\Scripts\activate

(.venv) C:\PyQt6\reflex_framework\my_app_catafest>pip install reflex
Collecting reflex
  Using cached reflex-0.8.26-py3-none-any.whl.metadata (13 kB)
...
Installing collected packages: wrapt, typing-extensions, redis, python-multipart, pygments, psutil, platformdirs, packaging, mdurl, MarkupSafe, idna, h11, greenlet, colorama, certifi, bidict, annotated-types, wsproto, typing-inspection, SQLAlchemy, pydantic-core, markdown-it-py, Mako, httpcore, click, anyio, watchfiles, starlette, simple-websocket, rich, pydantic, httpx, granian, alembic, sqlmodel, reflex-hosting-cli, python-engineio, python-socketio, reflex
Successfully installed Mako-1.3.10 MarkupSafe-3.0.3 SQLAlchemy-2.0.46 alembic-1.18.1 annotated-types-0.7.0 anyio-4.12.1 bidict-0.23.1 certifi-2026.1.4 click-8.3.1 colorama-0.4.6 granian-2.6.1 greenlet-3.3.1 h11-0.16.0 httpcore-1.0.9 httpx-0.28.1 idna-3.11 markdown-it-py-4.0.0 mdurl-0.1.2 packaging-25.0 platformdirs-4.5.1 psutil-7.2.1 pydantic-2.12.5 pydantic-core-2.41.5 pygments-2.19.2 python-engineio-4.13.0 python-multipart-0.0.22 python-socketio-5.16.0 redis-7.1.0 reflex-0.8.26 reflex-hosting-cli-0.1.61 rich-14.3.1 simple-websocket-1.1.0 sqlmodel-0.0.31 starlette-0.52.1 typing-extensions-4.15.0 typing-inspection-0.4.2 watchfiles-1.1.1 wrapt-2.0.1 wsproto-1.3.2

(.venv) C:\PyQt6\reflex_framework\my_app_catafest>reflex init
──────────────────────────────────────────── Initializing my_app_catafest ─────────────────────────────────────────────
[14:21:36] Initializing the web directory.                                         console.py:231

Get started with a template:
(0) A blank Reflex app.
(1) Premade templates built by the Reflex team.
(2) Try our AI builder.
Which template would you like to use? (0):
[14:21:39] Initializing the app directory.                                         console.py:231
Success: Initialized my_app_catafest using the blank template.

(.venv) C:\PyQt6\reflex_framework\my_app_catafest>reflex run
Warning: Windows Subsystem for Linux (WSL) is recommended for improving initial install times.
────────────────────────────────────── Starting Reflex App ──────────────────────────────────────
[14:27:31] Compiling: ---------------------------------------- 100% 21/21 0:00:02
⠙ Installing base frontend packages Resolving dependencies
... 

Python Qt6 : tasks with libraries.io

Today, I tested the libraries.io API to see what's new and what differences exist on the web and on my local installation and to be able to update the installed packages.

Python Qt6 : testing CatBoost with loto 6/49 numbers.

CatBoost is a high-performance library for gradient boosting on decision trees, developed by Yandex and used for various tasks. It supports categorical features, GPU version, improved

See the official webpage.

python -m pip install catboost
Collecting catboost
...
Installing collected packages: narwhals, plotly, catboost
Successfully installed catboost-1.2.8 narwhals-2.15.0 plotly-6.5.2

The source code implements a single, clean, fully self‑contained Python application that relies exclusively on real lottery data loaded from a text file. It computes all required numerical relationships for each draw, including digit distribution, statistical measures, and parity-based metrics. Using only the real historical draws, the program automatically builds a training dataset where each row uses the previous extraction as input and the next extraction’s digit distribution as the prediction target. It then trains two CatBoost regression models—one for forecasting how many one‑digit numbers will appear in the next draw, and another for predicting how many two‑digit numbers will appear. All computed metrics and model predictions are displayed in a structured PyQt6 table, ensuring that every result is derived entirely from the real data provided by the user.

I used 217 old real numbers from loto 6/49:

1 6 12 16 17 33
17 26 30 35 36 44
23 24 28 34 48 49
5 11 22 34 42 43
7 12 17 30 33 49
12 23 32 41 43 48
4 6 33 35 36 39
4 6 33 35 36 39
13 14 20 21 38 49
4 9 11 15 37 47
...

This is the result:

News : Intro to Gemini 2.0 Flash by google.

Gemini 2.0 Flash is a new multimodal generative ai model from the Gemini family developed by Google DeepMind. It is available through the Gemini API in Vertex AI and Vertex AI Studio.

The documentation online can be found on this official webpage.

See one example on this colab notebook.