Python : Fix DLL load failed while importing ...

This error DLL load failed while importing ... can have many causes like conflicts with the already installed packages, and also it can break your current environment.

>>> import PyQt6
>>> from PyQt6.QtCore import QUrl
Traceback (most recent call last):
  ...
ImportError: DLL load failed while importing QtCore: The specified module could not be found.

You can see I used to reinstall the PyQt6 python package with this argument --ignore-installed:

pip3 install PyQt6 --user --ignore-installed
Collecting PyQt6
  ...
Installing collected packages: PyQt6-Qt6, PyQt6-sip, PyQt6
  WARNING: The scripts pylupdate6.exe and pyuic6.exe are installed in
  ...
  which is not on PATH.
  Consider adding this directory to PATH or, if you prefer to suppress this warning, use --no-warn-script-location.
Successfully installed PyQt6-6.4.0 PyQt6-Qt6-6.4.2 PyQt6-sip-13.4.0

The --ignore-installed option for the pip package manager was first introduced in version 6.0, which was released in April 2014.

The old install give me this error and when I try to use I got this:

>>> from PyQt6 import *
>>> dir(PyQt6)
['__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__path__', '__spec__']

Now after I reinstall with this option the result is good:

>>> import PyQt6
>>> from PyQt6 import QtCore
>>> dir(PyQt6)
['QtCore', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__path__', '__spec__', 'sip']
>>> from PyQt6.QtCore import QUrl

Python 3.11.0 : The openai python package - part 001.

The OpenAI Python library provides convenient access to the OpenAI API from applications written in the Python language. It includes a pre-defined set of classes for API resources that initialize themselves dynamically from API responses which makes it compatible with a wide range of versions of the OpenAI API.

You can see more about this on the GitHub project.

in order to use this package you need to have a A.P.I. key for OpenAI beta features from this website.

Create a key and copy into file or clipboard beacuse this cannot be accesed after you created.

Use the pip tool to install the openai package:

pip3 install openai --user

I tested with a default example and a simple question: What is the python programmin language?

import os
import openai


openai.api_key = "your_API_OpenAI_key"

response = openai.Completion.create(
    model="text-davinci-003",
    prompt="What is the python programmin language?",
    temperature=0.7,
    max_tokens=100,
    top_p=1,
    frequency_penalty=0,
    presence_penalty=0
)

print(response)

I run this python script code and the result is this:

python openai001.py
{
  "choices": [
    {
      "finish_reason": "stop",
      "index": 0,
      "logprobs": null,
      "text": "\n\nPython is a high-level, interpreted, general-purpose programming language. 
      It was created by Guido van Rossum and first released in 1991. Python has a wide variety of 
      uses and is a popular language for data science, web development, automation, and artificial 
      intelligence. It is also a popular language for scripting and general-purpose programming."
    }
  ],
  "created": 1674588982,
  "id": "cmpl-6cJNeACMtayBlExV1GJpilde0KcBN",
  "model": "text-davinci-003",
  "object": "text_completion",
  "usage": {
    "completion_tokens": 71,
    "prompt_tokens": 8,
    "total_tokens": 79
  }
}

Python 3.11.0 : About py launcher tool for Windows.

The py launcher tool for Windows is included in the Python for Windows installer starting from version 3.3.

This command-line tool allows you to easily configure and switch between multiple versions of Python installed on a Windows system.

This tool allows you to easily switch between different versions of Python without modifying the system's PATH environment variable, and it also allows you to set default versions of Python for different file extensions.

Let's see some examples

This will argument will give you the current version of your python command:

py --version
Python 3.11.0

This will enumerate all your python versions from Windows O.S.:

py -0
 -V:3.11 *        Python 3.11 (64-bit)
 -V:3.10          Python 3.10 (64-bit)
 -V:3.9           Python 3.9 (64-bit)
 -V:3.7           Python 3.7 (64-bit)

This will set the python command to a specific version in this case 3.10 :

>py -3.10
Python 3.10.7 (tags/v3.10.7:6cc6b13, Sep  5 2022, 14:08:36) [MSC v.1933 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> exit()

This will run a python script named scripting001.py with a specific version of python:

py -3.10 scripting001.py

Python 3.11.0 : The parfive python package.

Today I tested this simple parfive 2.0.2 version python package with the default example from the official website.

A parallel file downloader using asyncio. parfive can handle downloading multiple files in parallel as well as downloading each file in a number of chunks.

The default example works great but when I try to get direct movie files from free web this not work.

Parfive is a lightweight library, I try to download large files but give me error 206.

Python 3.11.0 : The numpy-quaternion python package - part 001.

I write an article on my website about artificial intelligence and I used python to show a simple example with quaternions.

This Python module adds a quaternion dtype to NumPy and you can read about this on the official website.

I may have mistakenly installed a python packet with a similar name and I had to install it with the command:

python -m pip uninstall quaternion

the next step was to install this command

python -m pip install --upgrade --no-deps --force-reinstall numpy-quaternion

The source code I used defines two quaternions, one with real part a and imaginary parts, and one quaternion using Euler angles.

Then is perform the rotation uses quaternion multiplication.

Let's see the source code

import numpy as np
import quaternion

# define a quaternion with real part a and imaginary parts bi, cj, dk
a = 1
b = 2
c = 3
d = 4
q = np.quaternion(a, b, c, d)

# define a quaternion using euler angles
x = 1.0
y = 2.0
z = 3.0
q2 = quaternion.from_euler_angles(x, y, z)

# define a vector to rotate
v = [1, 0, 0]

# perform the rotation using quaternion multiplication

# quaternion multiplication is not commutative, the order matters
# because this line of source code will not work:  rotated_v = q2 * v * q2.conj()

rotated_v = (q2 * quaternion.quaternion(0, *v)) * q2.conj()

print(rotated_v)

This is the result:

quaternion(0, 0.103846565151668, 0.422918571742548, 0.900197629735517)

Python 3.7.9 : simple zodiac diagrams with ephem and matplotlib.

I used openai chat to test another issue with these python packages: ephem and matplotlib.

It seems that openai is limited to new changes in python packages, but it resolves quite well combinations of source code that it has corrected with defined errors. It can't really extract source code from general questions. Anyway, it is a very good help for a programmer in the initial phase of any project.

This source code show two diagrams about the solar system on a specific date:

import ephem
import matplotlib.pyplot as plt

# create an observer
obs = ephem.Observer()

# set the observer's location
obs.lat = '47.27' # latitude
obs.lon = '26.18' # longitude
obs.elevation = 307 # elevation (meters)

# set the date and time of the observation
obs.date = '2022/05/15 12:00:00' # date and time
# if you want you can use now() for real time data

# create the bodies
mercury = ephem.Mercury(obs)
venus = ephem.Venus(obs)
mars = ephem.Mars(obs)
jupiter = ephem.Jupiter(obs)
saturn = ephem.Saturn(obs)
uranus = ephem.Uranus(obs)
neptune = ephem.Neptune(obs)
pluto = ephem.Pluto(obs)
moon = ephem.Moon(obs) 

# compute the position of each planet and the moon
mercury.compute(obs)
venus.compute(obs)
mars.compute(obs)
jupiter.compute(obs)
saturn.compute(obs)
uranus.compute(obs)
neptune.compute(obs)
pluto.compute(obs)
moon.compute(obs)  

# extract ra and dec coordinates of each body
ra = [mercury.ra, venus.ra, mars.ra, jupiter.ra, saturn.ra, uranus.ra, neptune.ra, pluto.ra,moon.ra]
dec = [mercury.dec, venus.dec, mars.dec, jupiter.dec, saturn.dec, uranus.dec, neptune.dec, pluto.dec,moon.dec]

# convert ra,dec from radians to degrees
ra = [r*180/ephem.pi for r in ra]
dec = [d*180/ephem.pi for d in dec]
print(ra,dec)
# create a scatter plot of the positions
plt.scatter(ra, dec)

# add labels for each planet
plt.annotate('Mercury', (ra[0], dec[0]))
plt.annotate('Venus', (ra[1], dec[1]))
plt.annotate('Mars', (ra[2], dec[2]))
plt.annotate('Jupiter', (ra[3], dec[3]))
plt.annotate('Saturn', (ra[4], dec[4]))
plt.annotate('Uranus', (ra[5], dec[5]))
plt.annotate('Neptune', (ra[6], dec[6]))
plt.annotate('Pluto', (ra[7], dec[7]))
plt.annotate('Moon', (ra[8], dec[8]))

plt.xlabel("RA [degrees]")
plt.ylabel("Dec [degrees]")

# show the plot
plt.show()

# Set the figure size
plt.figure(figsize=(10, 10))

# Define the polar axis
ax = plt.subplot(111, projection='polar')

# Set the axis limits
ax.set_ylim(0, 36)

# Plot the Sun at the center
plt.scatter(0, 0, s=200, color='yellow')

mercury_distance = mercury.earth_distance
venus_distance= venus.earth_distance
mars_distance= mars.earth_distance
jupiter_distance= jupiter.earth_distance
saturn_distance= saturn.earth_distance
uranus_distance= uranus.earth_distance
neptune_distance= neptune.earth_distance
pluto_distance= pluto.earth_distance
moon_distance= moon.earth_distance
print(mercury_distance)
distance = [mercury_distance,venus_distance,mars_distance,jupiter_distance,saturn_distance,uranus_distance,neptune_distance,pluto_distance,moon_distance]

# Plot the planets
plt.scatter(ra[0], distance[0], s=20, color='green')
plt.scatter(ra[1], distance[1], s=50, color='orange')
plt.scatter(ra[2], distance[2], s=80, color='red')
plt.scatter(ra[3], distance[3], s=120, color='brown')
plt.scatter(ra[4], distance[4], s=150, color='tan')
plt.scatter(ra[5], distance[5], s=100, color='blue')
plt.scatter(ra[6], distance[6], s=80, color='cyan')
plt.scatter(ra[7], distance[7], s=40, color='purple')
plt.scatter(ra[8], distance[8], s=20, color='gray')

# add the labels for each planet
plt.annotate('Mercury',(ra[0], distance[0]),xytext=(ra[0], distance[0] - 2))
plt.annotate('Venus',(ra[1], distance[1]),xytext=(ra[1], distance[1] - 2))
plt.annotate('Mars',(ra[2], distance[2]),xytext=(ra[2], distance[2] - 2))
plt.annotate('Jupiter',(ra[3], distance[3]),xytext=(ra[3], distance[3] - 4))
plt.annotate('Saturn',(ra[4], distance[4]),xytext=(ra[4], distance[4] - 4))
plt.annotate('Uranus',(ra[5], distance[5]),xytext=(ra[5], distance[5] - 2))
plt.annotate('Neptune',(ra[6], distance[6]),xytext=(ra[6], distance[6] - 2))
plt.annotate('Pluto',(ra[7], distance[7]),xytext=(ra[7], distance[7] - 2))
plt.annotate('Moon',(ra[8], distance[8]),xytext=(ra[8], distance[8] - 2))

# Show the plot
plt.show()

This is the result of this source code:

Python 3.7.9 : simple zodiac constellation with ephem.

This time I used openai chat to create my source code and with small changes it worked…

PyEphem provides an ephem Python package for performing high-precision astronomy computations. The underlying numeric routines are coded in C and are the same ones that drive the popular XEphem astronomy application, whose author, Elwood Charles Downey, generously gave permission for their use in PyEphem. The name ephem is short for the word ephemeris, which is the traditional term for a table giving the position of a planet, asteroid, or comet for a series of dates.

import ephem

# create an observer
obs = ephem.Observer()

# set the observer's location
obs.lat = '47.27' # latitude
obs.lon = '26.18' # longitude
obs.elevation = 307 # elevation (meters)

# set the date and time of the observation
obs.date = '2022/05/15 12:00:00' # date and time

# create the bodies
mercury = ephem.Mercury(obs)
venus = ephem.Venus(obs)
mars = ephem.Mars(obs)
jupiter = ephem.Jupiter(obs)
saturn = ephem.Saturn(obs)
uranus = ephem.Uranus(obs)
neptune = ephem.Neptune(obs)
pluto = ephem.Pluto(obs)
moon = ephem.Moon(obs)

# print the constellation
print("Mercury:", ephem.constellation(mercury))
print("Venus:", ephem.constellation(venus))
print("Mars:", ephem.constellation(mars))
print("Jupiter:", ephem.constellation(jupiter))
print("Saturn:", ephem.constellation(saturn))
print("Uranus:", ephem.constellation(uranus))
print("Neptune:", ephem.constellation(neptune))
print("Pluto:", ephem.constellation(pluto))
print("Moon:", ephem.constellation(moon))

This is result of the running source code:

python constelation001.py
Mercury: ('Tau', 'Taurus')
Venus: ('Psc', 'Pisces')
Mars: ('Aqr', 'Aquarius')
Jupiter: ('Psc', 'Pisces')
Saturn: ('Cap', 'Capricornus')
Uranus: ('Ari', 'Aries')
Neptune: ('Psc', 'Pisces')
Pluto: ('Sgr', 'Sagittarius')
Moon: ('Lib', 'Libra')

Python 3.7.9 : simple zodiac with pyephem and ephem.

I don't know how to calculate a zodiac exactly, from what I understand the planets and the moon must overlap. so I tested a script that calculates the dates between the planets and the moon when they appear within one degree of each other and displays them in an array with rows and columns created from these planets and the moon. The intersections on the diagonal should be none because there's obviously no way to overlap the same object, and they only occur when there's this less than one degree rule.

If you think it is wrong then you can try to fix it.

You can install pyephem and ephem with pip tool, I used both python packages:

pip install pyephem --user
Requirement already satisfied: pyephem in 
... site-packages (9.99)
Requirement already satisfied: ephem in 
...
site-packages (from pyephem) (4.1.4)

This is the source script.

import ephem

# create a list with planets objects from ephem
planets = [ephem.Mercury(), ephem.Venus(), ephem.Mars(), ephem.Jupiter(), ephem.Saturn(), ephem.Uranus(), ephem.Neptune(), ephem.Moon()]

start_date = ephem.Date("2023/01/01")
end_date = ephem.Date("2023/12/31")
date = start_date

# create matrix to store planet names and conjunction dates
matrix = [[None for _ in range(len(planets) + 1)] for _ in range(len(planets))]

# create list to store planet names
planet_names = [planet.name for planet in planets]
# list all planets names as first row in matrix
matrix.insert(0, [""] + planet_names)

while date < end_date:
    for i, planet1 in enumerate(planets):
        for j, planet2 in enumerate(planets):
            if i < j:
                planet1.compute(date)
                planet2.compute(date)
                sep = ephem.separation(planet1, planet2) #  calculate the angular distance
                # compare the separation, if less than 0.01 degree then it's a conjunction
                if sep < 1.0:
                    date_formatted = date.datetime().strftime("%d %B %Y")
                    matrix[i+1][j+1] = date_formatted
                    break
    date = ephem.Date(date + 1)
# print a matrix with date is separation from 1 degree between planets on rows and column
for row in matrix:
    print(row)

This is the result:

['', 'Mercury', 'Venus', 'Mars', 'Jupiter', 'Saturn', 'Uranus', 'Neptune', 'Moon']
[None, None, '30 December 2023', '14 December 2023', '20 June 2023', None, None, None, None]
[None, None, None, '30 December 2023', '15 March 2023', '06 January 2023', None, None, '12 October 2023']
[None, None, None, None, None, None, '24 April 2023', None, '16 December 2023']
[None, None, None, None, None, '05 June 2023', '30 December 2023', None, None]
[None, None, None, None, None, None, None, '30 December 2023', None]
[None, None, None, None, None, None, None, '30 December 2023', None]
[None, None, None, None, None, None, None, None, '23 December 2023']
[None, None, None, None, None, None, None, None, None]

Python 3.7.9 : The sunpy python package - part 001.

In the past, I have written several small tutorials related to this Python package. Now I have some news related to the sunpy python package:

• HelioviewerClient is deprecated;
• The Helioviewer Project now maintains a Python Wrapper called hvpy.
• sunpy users are encouraged to upgrade parfive python package;
• the sunpy.database deprecation;
the sample data files provided through sunpy.data.sample are now downloaded individually on demand;
• SunPy is tested against Python 2.7, 3.5, and 3.6.;
• SunPy no longer supports Python 3.4.;
• easy to extract data values from a GenericMap along a curve specified by a set of coordinates using the new sunpy.map.extract_along_coord function;
• has a new make_heliographic_header() function that simplifies creating map headers that span the whole solar surface in Carrington or Stonyhurst coordinates;
• aiaprep is now deprecated;
• ... and more on the official website.

I install this python package on the Windows OS with the pip tool:

pip install "sunpy[all] -U"

You can install extra available options: [asdf], [dask], [database], [image], [jpeg2000], [map], [net], [timeseries], [visualization].

You can see the version of this python package with this source code:

 import sunpy
print(sunpy.__version__)
3.1.8

I tested this package with this simple source code:

from matplotlib import pyplot as plt
import sunpy.map
import sunpy.data.sample  
sunpyAIA = sunpy.map.Map(sunpy.data.sample.AIA_171_IMAGE) 
sunpyAIA.plot()
plt.colorbar()
plt.show()

The instrument is AIA and the measurement is 171, see more on this online tool named helioviewer.

After I run I got this image:

Python 3.11.0 : The scapy python module - part 003.

Scapy is a powerful interactive packet manipulation program. It is able to forge or decode packets of a wide number of protocols, send them on the wire, capture them, match requests and replies, and much more. It can easily handle most classical tasks like scanning, tracerouting, probing, unit tests, attacks or network discovery (it can replace hping, 85% of nmap, arpspoof, arp-sk, arping, tcpdump, tshark, p0f, etc.). It also performs very well at a lot of other specific tasks that most other tools can’t handle, like sending invalid frames, injecting your own 802.11 frames, combining technics (VLAN hopping+ARP cache poisoning, VOIP decoding on WEP encrypted channel, …), etc.

First, you need to install it with pip tool: pip install scapy --user.

I used with WinPcap from this webpage, but you will see the recomandation is to use Npcap.

#!/usr/bin/env python3
import os
print(os.sys.path)
from scapy.all import *

def mysniff(interface):
    sniff(iface=interface, store=False, prn=process_sniffed_packet)

def process_sniffed_packet(packet):
    pyperclip.copy(str(packet))
    print(packet)

mysniff("Realtek PCIe GbE Family Controller")

The running result is something like this:

...
WARNING: WinPcap is now deprecated (not maintained). Please use Npcap instead
Ether / IP / TCP 104.244.42.2:https > 192.168.0.143:55478 PA / Raw
Ether / IP / TCP 192.168.0.143:55478 > 104.244.42.2:https PA / Raw
Ether / IP / TCP 192.168.0.143:55478 > 104.244.42.2:https PA / Raw
Ether / IP / TCP 104.244.42.2:https > 192.168.0.143:55478 A / Padding
Ether / IP / TCP 104.244.42.2:https > 192.168.0.143:55478 A / Padding
Ether / ARP who has 192.168.0.1 says 192.168.0.206 / Padding
...

Python 3.7.9 : how to fix update errors between pip and setuptools.

The python language was mainly developed to emphasis on code readability.

That's why I think that it should not be affected by such errors, but they are easily fixed ...

    launcher = self._get_launcher('t')
  File "C:\Users\catafest\AppData\Roaming\Python\Python37\site-packages\pip\_vendor\distlib\scripts.py", line 404, in _get_launcher
    raise ValueError(msg)
ValueError: Unable to find resource t64.exe in package pip._vendor.distlib

[notice] A new release of pip available: 22.3 -> 22.3.1
[notice] To update, run: python.exe -m pip install --upgrade pip

C:\PythonProjects\scapy001>python -m pip uninstall pip setuptools
Found existing installation: pip 22.3
Uninstalling pip-22.3:
  Would remove:
    c:\users\catafest\appdata\roaming\python\python37\scripts\pip.exe
    c:\users\catafest\appdata\roaming\python\python37\scripts\pip3.10.exe
    c:\users\catafest\appdata\roaming\python\python37\scripts\pip3.7.exe
    c:\users\catafest\appdata\roaming\python\python37\scripts\pip3.exe
    c:\users\catafest\appdata\roaming\python\python37\site-packages\pip-22.3.dist-info\*
    c:\users\catafest\appdata\roaming\python\python37\site-packages\pip\*
Proceed (Y/n)? y
  Successfully uninstalled pip-22.3
Found existing installation: setuptools 47.1.0
Uninstalling setuptools-47.1.0:
  Would remove:
    c:\python379\lib\site-packages\easy_install.py
    c:\python379\lib\site-packages\pkg_resources\*
    c:\python379\lib\site-packages\setuptools-47.1.0.dist-info\*
    c:\python379\lib\site-packages\setuptools\*
    c:\python379\scripts\easy_install-3.7.exe
    c:\python379\scripts\easy_install.exe
Proceed (Y/n)? y
  Successfully uninstalled setuptools-47.1.0

C:\PythonProjects\scapy001>pip3 install --upgrade pip
Requirement already satisfied: pip in c:\python379\lib\site-packages (22.3.1)

C:\PythonProjects\scapy001>pip install --upgrade setuptools
Collecting setuptools
  Downloading setuptools-65.6.3-py3-none-any.whl (1.2 MB)
     ---------------------------------------- 1.2/1.2 MB 4.1 MB/s eta 0:00:00
Installing collected packages: setuptools
Successfully installed setuptools-65.6.3

Python Qt6 : Create a tray icon application.

The notification area known as system tray is located in the Windows Taskbar area, usually at the bottom right corner.

I tested with:

Python 3.10.2 (tags/v3.10.2:a58ebcc, Jan 17 2022, 14:12:15) [MSC v.1929 64 bit (AMD64)] on win32
...
pip show pyqt6
Name: PyQt6
Version: 6.4.0
Summary: Python bindings for the Qt cross platform application toolkit

I created a trayicon application with PyQt6 that show a menu with two entry: Show Window and Exit.

The Show Window will sow a default window and the Exit will close the application.

This is the source code I tested, you need an icon.png in the same folder with this script.

import sys
from PyQt6.QtCore import Qt, QEvent, QPoint
from PyQt6.QtGui import QGuiApplication, QIcon, QAction
from PyQt6.QtWidgets import QApplication, QSystemTrayIcon, QMainWindow, QMenu

# create the default application
app = QApplication(sys.argv)

# create the main window
window = QMainWindow()
# set the title for the window
window.setWindowTitle("My Window")

# this set the tray icon and menu
tray_icon = QSystemTrayIcon()
tray_icon.setIcon(QIcon("icon.png"))
menu = QMenu()

# add an action to the menu to show the window
show_window_action = QAction("Show Window", None)
show_window_action.triggered.connect(window.show)
menu.addAction(show_window_action)

# add an action to the menu to exit the application
exit_action = QAction("Exit", None)
exit_action.triggered.connect(app.quit)
menu.addAction(exit_action)

# set the context menu
tray_icon.setContextMenu(menu)

# show the tray icon
tray_icon.show()

# run the application
app.exec()

Python 3.10.2 : about ChemSpiPy.

ChemSpiPy provides a way to interact with ChemSpider in Python. It allows chemical searches, chemical file downloads, depiction and retrieval of chemical properties...

You can read more about this python package on the official website and the documentation for this python package.

You have to create an account and fill in the data to get an A.P.I key...

This is the source code for this python package , I use PyQt6 to show image formula with:QPixmap.fromImage.

import chemspipy

# set the API key from https://developer.rsc.org/my-apps/
api_key = "... your A.P.I. key ..."

# import the ChemSpider class
from chemspipy import ChemSpider

# instance of the ChemSpider class
cs_inst = ChemSpider(api_key)

compound_name = "Glucose"
# search for compound: "Glucose"
compounds  = cs_inst.search(compound_name) 

# get the first compound in the list
compound = compounds[0]

# print the list of the attributes and methods of 'compound' object
print(dir(compound))

# Print the compound's properties
print("... some compound's properties !")
print(f"Name: {compound.common_name}")
print(f"Average_mass: {compound.average_mass}")
print(f"ChemSpider ID - csid: {compound.csid}")
#print(f" external_references: {compound.external_references}")
#print(f" image: {compound.image}")
#print(f" mol_2d: {compound.mol_2d}")
#print(f" mol_3d: {compound.mol_3d}")
print(f" molecular_formula: {compound.molecular_formula}")
print(f" molecular_weight: {compound.molecular_weight}")
print(f" monoisotopic_mass: {compound.monoisotopic_mass}")
print(f" nominal_mass: {compound.nominal_mass}")


import sys
from PyQt6.QtCore import Qt
from PyQt6.QtGui import QPixmap, QImage, QColor
from PyQt6.QtWidgets import QApplication, QMainWindow, QLabel

# Create the application
app = QApplication(sys.argv)

# Create the main window
window = QMainWindow()
window.setWindowTitle(compound_name)

# Load the image with fromData
image = QImage.fromData(compound.image)

# Create a label to display the image
label = QLabel()
label.setPixmap(QPixmap.fromImage(image))

# Set the label as the central widget of the window
window.setCentralWidget(label)

# Show the window
window.show()

# Run the application
app.exec()

This is the result of running the source code: