Python313 : testing the potracer python package.

Pure Python Port of Potrace. This is a python port of Peter Selinger's Potrace (based on 1.16 code).

Today, I install the python package with pip tool:

pip install potracer[cli]
Collecting potracer[cli]
...
Successfully installed potrace-cli-0.0.4 potracer-0.0.4

The dir command show me all of these :

dir(potrace)
['BezierSegment', 'Bitmap', 'COS179', 'CornerSegment', 'Curve', 'INFTY', 'Optional', 'POTRACE_CORNER', 
'POTRACE_CURVETO', 'POTRACE_TURNPOLICY_BLACK', 'POTRACE_TURNPOLICY_LEFT', 'POTRACE_TURNPOLICY_MAJORITY',
'POTRACE_TURNPOLICY_MINORITY', 'POTRACE_TURNPOLICY_RANDOM', 'POTRACE_TURNPOLICY_RIGHT', 'POTRACE_TURNPOLICY_WHITE',
'Path', 'Tuple', 'Union', '_Curve', '_Path', '_Point', '_Segment', '_Sums', '__builtins__', '__cached__', '__doc__',
'__file__', '__loader__', '__name__', '__package__', '__spec__', '_adjust_vertices', '_bestpolygon', '_calc_lon',
'_calc_sums', '_opticurve', '_smooth', 'bezier', 'bm_to_pathlist', 'cprod', 'cyclic', 'ddenom', 'ddist', 'detrand',
'detrand_t', 'dorth_infty', 'dpara', 'findnext', 'findpath', 'floordiv', 'interval', 'iprod', 'iprod1', 'majority',
'math', 'mod', 'np', 'opti_penalty', 'opti_t', 'pathlist_to_tree', 'penalty3', 'pointslope', 'process_path', 'quadform',
'reverse', 'setbbox_path', 'sign', 'sq', 'tangent', 'xor_path', 'xor_to_ref', 'xprod']

See GitHub project from the tatarize.

I used the default example from the github project and works very well.

Python Qt6 : use default PyQt styles to PyQt6 applications.

Today, about PyQt Styles to PyQt6 Applications.

This works with default themes and how to change these, and using different types of custom styling.

First , let's see the source code with default themes:

from PyQt6.QtWidgets import QStyleFactory
print(QStyleFactory.keys())
['windows11', 'windowsvista', 'Windows', 'Fusion']

Let's see the source code for this simple script with this theme windows11:

import sys
from PyQt6.QtWidgets import (
    QApplication, QLabel, QLineEdit, QComboBox, QPushButton,
    QCheckBox, QSlider, QVBoxLayout, QWidget
)
from PyQt6.QtCore import Qt

app = QApplication(sys.argv)
app.setStyle('windows11')

window = QWidget()
layout = QVBoxLayout(window)

# 1. QLabel
layout.addWidget(QLabel("Acesta este un QLabel"))

# 2. QLineEdit
layout.addWidget(QLineEdit("Text editabil"))

# 3. QComboBox
combo = QComboBox()
combo.addItems(["Optiunea 1", "Optiunea 2", "Optiunea 3"])
layout.addWidget(combo)

# 4. QCheckBox
layout.addWidget(QCheckBox("Bifează această opțiune"))

# 5. QSlider
slider = QSlider(Qt.Orientation.Horizontal)
layout.addWidget(slider)

# 5. QPushButton
button = QPushButton('Simple button !')
layout.addWidget(button)

# show the main windows 
window.show()
sys.exit(app.exec())

News : PyQt v6.10.2 Released .

PyQt v6.10.2 has been released. This is a bug-fix release.

• Fixed a regression introduced in v6.5.0 in the handling of the return value of QSqlQueryModel.query().
• Fixed a regression introduced in v6.10.1 in the handling of the return value of createMimeDataFromSelection() in QTextEdit and QPlainTextEdit.

See the official website.

Python Qt6 : Check certificate of url.

Today, I will show this python script to check the certificate of url.

import sys
import ssl
import socket
from datetime import datetime

from cryptography import x509
from cryptography.hazmat.backends import default_backend

from PyQt6.QtWidgets import (
    QApplication, QWidget, QVBoxLayout, QLabel,
    QLineEdit, QPushButton, QTextEdit
)

def fetch_certificate_raw(hostname):
    """
    Connects to the server and retrieves the certificate in DER format.
    Also returns a validation status message.
    """

    # Create a default SSL context (validates certificates)
    context = ssl.create_default_context()

    try:
        # First attempt: strict validation
        with socket.create_connection((hostname, 443), timeout=5) as sock:
            with context.wrap_socket(sock, server_hostname=hostname) as ssock:
                der_cert = ssock.getpeercert(binary_form=True)
                return der_cert, "Certificate is VALID"

    except ssl.SSLError as e:
        # Certificate is invalid → try to retrieve it anyway
        try:
            unverified_context = ssl._create_unverified_context()
            with socket.create_connection((hostname, 443), timeout=5) as sock:
                with unverified_context.wrap_socket(sock, server_hostname=hostname) as ssock:
                    der_cert = ssock.getpeercert(binary_form=True)
                    return der_cert, f"Certificate is INVALID: {str(e)}"
        except Exception:
            return None, f"Could not retrieve certificate: {str(e)}"

    except Exception as e:
        return None, f"Connection error: {str(e)}"

def parse_certificate(der_cert):
    """
    Converts a DER-encoded certificate into a cryptography.x509 object.
    """
    return x509.load_der_x509_certificate(der_cert, default_backend())

class CertViewer(QWidget):
    """
    Main GUI window for the HTTPS certificate viewer.
    """
    def __init__(self):
        super().__init__()

        self.setWindowTitle("HTTPS Certificate Checker")
        self.setGeometry(200, 200, 700, 600)

        layout = QVBoxLayout()

        # Input label + text field
        layout.addWidget(QLabel("Enter URL (example: example.com):"))
        self.input = QLineEdit()
        layout.addWidget(self.input)

        # Button to trigger certificate check
        self.button = QPushButton("Check Certificate")
        self.button.clicked.connect(self.check_certificate)
        layout.addWidget(self.button)

        # Output text box
        self.output = QTextEdit()
        self.output.setReadOnly(True)
        layout.addWidget(self.output)

        self.setLayout(layout)

    def check_certificate(self):
        """
        Triggered when the user presses the button.
        Retrieves and displays certificate information.
        """

        hostname = self.input.text().strip()

        # Clean URL (remove http://, https://, and paths)
        for prefix in ("https://", "http://"):
            if hostname.startswith(prefix):
                hostname = hostname[len(prefix):]

        hostname = hostname.split("/")[0]

        # Fetch certificate
        der_cert, status = fetch_certificate_raw(hostname)

        if der_cert is None:
            self.output.setText(status)
            return

        # Parse certificate
        cert = parse_certificate(der_cert)

        # Build output text
        text = f"=== CERTIFICATE STATUS ===\n{status}\n\n"
        text += "=== CERTIFICATE DETAILS ===\n\n"

        text += f"Subject:\n{cert.subject}\n\n"
        text += f"Issuer:\n{cert.issuer}\n\n"
        text += f"Serial Number: {cert.serial_number}\n\n"
        text += f"Version: {cert.version}\n\n"
        text += f"Valid From: {cert.not_valid_before}\n"
        text += f"Valid To:   {cert.not_valid_after}\n\n"

        # Check expiration
        if cert.not_valid_after < datetime.utcnow():
            text += f"⚠ Certificate EXPIRED on: {cert.not_valid_after}\n\n"

        # Subject Alternative Names (SAN)
        try:
            san = cert.extensions.get_extension_for_class(x509.SubjectAlternativeName)
            text += f"Subject Alternative Names:\n{san.value}\n\n"
        except Exception:
            text += "Subject Alternative Names: (none)\n\n"

        self.output.setText(text)

if __name__ == "__main__":
    app = QApplication(sys.argv)
    viewer = CertViewer()
    viewer.show()
    sys.exit(app.exec())

Python 3.13.0 : PyWin32 is full compatible with Python 3.13 .

Today I tried to use these python packages:

import win32serviceutil
import win32service
import win32event
import servicemanager

The works , but python -m pywin32_postinstall -install comes with:

python.exe: No module named pywin32_postinstall

NOTE : The copilot artificial intelligence, search and give me an old answer , but is wrong ...

PyWin32 is updated slowly, and at this moment there are no wheels for Python 3.13.

The pip tool cannot install pywin32 does not install anything usable, and pywin32_postinstall does not exist

Possible solutions

PyWin32 works perfectly on:

• Python 3.12
• Python 3.11
• Python 3.10

If you need win32service, win32api, win32com, etc., you must use a supported version.

Need to see the last tutorial from my blogger.

I tested on admin with simple service and works:

python service_test_001.py install
Installing service MyPythonService
Service installed

This is the source code:

import win32serviceutil
import win32service
import win32event
import servicemanager
import time

class MyService(win32serviceutil.ServiceFramework):
    _svc_name_ = "MyPythonService"
    _svc_display_name_ = "My Python Windows Service"
    _svc_description_ = "A minimal Windows service example written in Python."

    def __init__(self, args):
        win32serviceutil.ServiceFramework.__init__(self, args)
        self.stop_event = win32event.CreateEvent(None, 0, 0, None)
        self.running = True

    def SvcStop(self):
        self.ReportServiceStatus(win32service.SERVICE_STOP_PENDING)
        win32event.SetEvent(self.stop_event)
        self.running = False

    def SvcDoRun(self):
        servicemanager.LogInfoMsg("MyPythonService is starting.")
        self.main()

    def main(self):
        while self.running:
            # Your service logic goes here
            time.sleep(5)
            servicemanager.LogInfoMsg("MyPythonService heartbeat.")


if __name__ == '__main__':
    win32serviceutil.HandleCommandLine(MyService)

Python 3.13.0 : how to install pywin32_postinstall.

Today a tutorial on how to install pywin32_postinstall.

This package is essential for accessing Windows-specific functionalities in Python.

The pywin32_postinstall missing python error typically occurs when the pywin32 package is not properly installed or the post-installation script is not executed correctly.

Fisrt install the pywin32 python package.

pip install pywin32

The next step is to run this command on the path with Script folder.

python C:\Python313\Scripts\pywin32_postinstall.py -install
Parsed arguments are: Namespace(install=True, remove=False, wait=None, silent=False, quiet=False, destination= ...

The next step is to run this command on the path with Script folder.

D:\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 win32api
>>> print(win32api.GetVersion())

Python Qt6 : script for impact on your development workflow using scans features.

Impact on development workflows that rely on Language Server Protocol (LSP) features.

1. Editor Limitations

Your editor (VS Code, Neovim, Qt Creator, etc.) attempts to send a file to the Language Server, but the file is not accessible through the file:// protocol.

When this happens, the LSP rejects the request, and you lose essential features such as:

• IntelliSense
• Autocomplete
• Hover information
• Diagnostics
• Jump‑to‑definition
• Refactoring tools

2. Issues in Non‑Standard Projects

This limitation becomes more severe when working with:

• dynamically generated files
• files inside containers
• remote workspaces
• build systems that create temporary or virtual files

Since the LSP cannot process these resources, you lose intelligent code support.

3. Toolchain Breakdowns

If you rely on an automated workflow (analysis, diagnostics, UI integration, etc.), an LSP restricted to file:// can break:

• static analysis
• code validation
• report generation
• plugin integrations

Real Risks in Development

1. False or Incomplete Diagnostics

The LSP may not see the actual files, leading to:

• false errors
• missed real errors

2. Dangerous Refactoring

If the LSP cannot access all files, automated refactoring may:

• fail to update all references
• introduce new bugs

3. Reduced Productivity

Without full LSP support, you lose:

• intelligent completion
• fast navigation
• real‑time validation

4. Incompatibility With Modern Tooling

Many modern IDEs rely on virtual or remote workspaces. An LSP limited to file:// becomes outdated quickly.

5. Indirect Security Risks

Not a vulnerability by itself, but:

• if the LSP cannot analyze remote files, you may miss security issues in generated or synchronized code.

I tested with a simple python source code to detect how bad is running on I.D.E. The script continuously scans your Windows system to detect, analyze, and report the real‑time behavior, resource usage, crashes, leaks, ports, and child processes of all VS Code, LSP, and Antigravity components, showing their impact on your development workflow through a live PyQt6 dashboard.

The result after runnig is:

Python Qt6 : QCalendarWidget simple example with csv file.

Here is a simple example of source code with PyQt6 and QCalendarWidget to create a calendar. You click on the date and enter a note. This is saved in a file with the date time ... and the note. When you reopen the script, it opens in notepad and the saved notes. Obviously it is a simple example but you can improve it with databases, make a note management, encrypt it, link it to an external database, etc.

import sys
import csv
import os
import subprocess
from datetime import datetime
from PyQt6.QtWidgets import (
    QApplication, QWidget, QVBoxLayout, QCalendarWidget,
    QInputDialog, QMessageBox
)
from PyQt6.QtCore import QDate


CSV_FILE = "note.csv"


class CalendarApp(QWidget):
    def __init__(self):
        super().__init__()
        self.setWindowTitle("Calendar cu notițe")
        self.resize(400, 300)

        self.layout = QVBoxLayout()
        self.setLayout(self.layout)

        self.calendar = QCalendarWidget()
        self.calendar.clicked.connect(self.adauga_nota)
        self.layout.addWidget(self.calendar)

        # Dicționar pentru notițe
        self.note = {}

        # La pornire, citește CSV și deschide în Notepad
        self.incarca_note()

    def adauga_nota(self, date: QDate):
        zi = date.toString("yyyy-MM-dd")

        text, ok = QInputDialog.getText(self, "Adaugă notiță",
                                        f"Introdu text pentru {zi}:")
        if ok and text.strip():
            timestamp = datetime.now().strftime("%Y-%m-%d %H:%M")
            self.note[timestamp] = text.strip()
            QMessageBox.information(self, "Salvat",
                                    "Notița a fost adăugată.")

    def incarca_note(self):
        if os.path.exists(CSV_FILE):
            try:
                with open(CSV_FILE, "r", newline="", encoding="utf-8") as f:
                    reader = csv.reader(f)
                    for row in reader:
                        if len(row) == 2:
                            self.note[row[0]] = row[1]

                # Deschide în Notepad
                subprocess.Popen(["notepad.exe", CSV_FILE])

            except Exception as e:
                QMessageBox.warning(self, "Eroare",
                                    f"Nu pot citi fișierul CSV:\n{e}")

    def closeEvent(self, event):
        try:
            with open(CSV_FILE, "w", newline="", encoding="utf-8") as f:
                writer = csv.writer(f)
                for timestamp, text in self.note.items():
                    writer.writerow([timestamp, text])
        except Exception as e:
            QMessageBox.warning(self, "Eroare",
                                f"Nu pot salva fișierul CSV:\n{e}")

        event.accept()


if __name__ == "__main__":
    app = QApplication(sys.argv)
    window = CalendarApp()
    window.show()
    sys.exit(app.exec())

... this is the result:

Python 3.12.12 : simple example with CompVis/stable-diffusion-v1-4 model on colab.

Because this year we need to start it as advanced and more prepared as we know and can do ...

Today I tested a simple source code with an interactive interface for text-to-image generation based on the CompVis/stable-diffusion-v1-4 model.

This is not an advanced model and you will have some dizzy images, but the learnning idea is the base of these colabs notebooks.

See the default example on my colab github project.

The colab notebook use this python version:

Python 3.12.12 (main, Oct 10 2025, 08:52:57) [GCC 11.4.0] on linux
Type "help", "copyright", "credits" or "license" for more information.

I'm mode advanced with some models like SDXL, image generation is not a priority at the moment ...

... and first image result is this:

Python Qt6 : video processing and background remover and sprites tool

It seems that the intrusion blocked my python and pip tool in command ... but I managed to create a tool with the python modules I had installed that would automatically remove my background and create sprites after a crop selection ... here's what it looks like with the character from the Easter project.

... and result with crop and remove the green color from background:

Python Qt6 : testing local web server with PyQt versus Ollama.

This Python program creates a PyQt6 GUI that measures latency for a given URL.

It runs a background thread that repeatedly sends HTTP requests and calculates two values:

The results are sent back to the GUI using Qt signals and displayed live without freezing the interface.

• HTTP latency (time for the request to complete)
• Thread latency (total duration of one worker cycle)

See the result in this screenshot:

Python Qt6 : Run Visual Studio Code directly from RAM using ImDisk and python.

I built a small tool using Python + PyQt6 that lets me run Visual Studio Code directly from a RAM Disk for maximum speed and minimal SSD wear.

The setup uses ImDisk Toolkit to automatically create a 6 GB RAM Disk (drive O:).

The tool then copies VS Code into RAM and launches it instantly through a simple graphical interface with three buttons:

• Create RAM Disk
• Copy VS Code to RAM
• Launch VS Code from RAM

This method provides much faster startup times and a smoother workflow, making it a great performance boost for Windows users.

News : Reporting a security issue - good practice.

This is how the python solve a security issue:

We take security very seriously and ask that you follow our security policy carefully.

If you've identified a security issue with a project hosted on PyPI.

Login to your PyPI account, then visit the project's page on PyPI. At the bottom of the sidebar, click Report project as malware. Supply the following details in the form:

• A URL to the project in question
• An explanation of what makes the project a security issue
• A link to the problematic lines in the project's distributions via inspector.pypi.io

Important! If you believe you've identified a security issue with PyPI, DO NOT report the issue in any public forum, including (but not limited to):

• Our GitHub issue tracker
• Official or unofficial chat channels
• Official or unofficial mailing lists

See the official webpage.