quplots 0.0.1__tar.gz

quplots-0.0.1/.gitignore

@@ -0,0 +1,5 @@
+# Ignorar carpetas generadas
+build/
+dist/
+*.egg-info/
+__pycache__/

quplots-0.0.1/LICENSE.txt

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) 2025-present Adrian <kerpador@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

quplots-0.0.1/PKG-INFO

@@ -0,0 +1,51 @@
+Metadata-Version: 2.4
+Name: quplots
+Version: 0.0.1
+Summary: Allows you to visualize and interact with plots that describes quantum phenoms
+Project-URL: Documentation, https://github.com/JoseAdrianRodriguezGonzalez/quplots#readme
+Project-URL: Issues, https://github.com/JoseAdrianRodriguezGonzalez/quplots/issues
+Project-URL: Source, https://github.com/JoseAdrianRodriguezGonzalez/quplots
+Author-email: Adrian <kerpador@gmail.com>, Isabel <isabelrocha31415@gmail.com>
+License-Expression: MIT
+License-File: LICENSE.txt
+Keywords: interactive,physics,plots,quantum,visualization
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Topic :: Scientific/Engineering :: Physics
+Classifier: Topic :: Scientific/Engineering :: Visualization
+Requires-Python: >=3.10
+Requires-Dist: matplotlib>=3.6.0
+Requires-Dist: numpy>=1.23.0
+Requires-Dist: plotly>=5.0.0
+Requires-Dist: scipy>=1.9.0
+Description-Content-Type: text/markdown
+
+# QuPlots
+
+[![PyPI - Version](https://img.shields.io/pypi/v/quplots.svg)](https://pypi.org/project/quplots)
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/quplots.svg)](https://pypi.org/project/quplots)
+
+-----
+
+## Table of Contents
+
+- [Installation](#installation)
+- [License](#license)
+
+## Installation
+
+```console
+pip install quplots
+```
+
+## License
+
+`quplots` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.

quplots-0.0.1/README.md

@@ -0,0 +1,21 @@
+# QuPlots
+
+[![PyPI - Version](https://img.shields.io/pypi/v/quplots.svg)](https://pypi.org/project/quplots)
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/quplots.svg)](https://pypi.org/project/quplots)
+
+-----
+
+## Table of Contents
+
+- [Installation](#installation)
+- [License](#license)
+
+## Installation
+
+```console
+pip install quplots
+```
+
+## License
+
+`quplots` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.

quplots-0.0.1/pyproject.toml

@@ -0,0 +1,66 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "quplots"
+dynamic = ["version"]
+description = 'Allows you to visualize and interact with plots that describes quantum phenoms'
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+keywords = ["quantum", "plots", "visualization", "interactive", "physics"]
+authors = [
+  { name = "Adrian", email = "kerpador@gmail.com" },
+  {name="Isabel",email="isabelrocha31415@gmail.com"}
+]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Programming Language :: Python",
+  "Programming Language :: Python :: 3.8",
+  "Programming Language :: Python :: 3.9",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: Implementation :: CPython",
+  "Programming Language :: Python :: Implementation :: PyPy",
+  "Intended Audience :: Science/Research",
+  "Topic :: Scientific/Engineering :: Physics",
+  "Topic :: Scientific/Engineering :: Visualization",
+]
+dependencies = ['numpy>=1.23.0','matplotlib>=3.6.0','plotly>=5.0.0','scipy>=1.9.0']
+
+[project.urls]
+Documentation = "https://github.com/JoseAdrianRodriguezGonzalez/quplots#readme"
+Issues = "https://github.com/JoseAdrianRodriguezGonzalez/quplots/issues"
+Source = "https://github.com/JoseAdrianRodriguezGonzalez/quplots"
+
+
+[tool.hatch.version]
+path = "src/quplots/__about__.py"
+
+[tool.hatch.envs.types]
+extra-dependencies = [
+  "mypy>=1.0.0",
+]
+[tool.hatch.envs.types.scripts]
+check = "mypy --install-types --non-interactive {args:src/quplots tests}"
+
+[tool.coverage.run]
+source_pkgs = ["quplots", "tests"]
+branch = true
+parallel = true
+omit = [
+  "src/quplots/__about__.py",
+]
+
+[tool.coverage.paths]
+quplots = ["src/quplots", "*/quplots/src/quplots"]
+tests = ["tests", "*/quplots/tests"]
+
+[tool.coverage.report]
+exclude_lines = [
+  "no cov",
+  "if __name__ == .__main__.:",
+  "if TYPE_CHECKING:",
+]

quplots-0.0.1/pytest.ini

@@ -0,0 +1,3 @@
+# pytest.ini
+[pytest]
+pythonpath = src

quplots-0.0.1/src/quplots/__about__.py

@@ -0,0 +1,5 @@
+# SPDX-FileCopyrightText: 2025-present Adrian <kerpador@gmail.com>
+#
+# SPDX-License-Identifier: MIT
+#__version__ = "0.0.2a4"
+__version__ = "0.0.1"

quplots-0.0.1/src/quplots/__init__.py

@@ -0,0 +1,6 @@
+# SPDX-FileCopyrightText: 2025-present Adrian <kerpador@gmail.com>
+#
+# SPDX-License-Identifier: MIT
+from .hibrydization.hybridization import hybridization
+from .electron.electron import electron
+from .plots.plots import plots

quplots-0.0.1/src/quplots/electron/coordinates.py

@@ -0,0 +1,10 @@
+import numpy as np
+def Cartesian_definition():
+    xyz = np.linspace(-10, 10, 51)
+    x,y,z = np.meshgrid(xyz, xyz, xyz, sparse=False)
+    return x,y,z
+def CartesianToSpherical(x,y,z):
+    r = np.sqrt(x**2 + y**2 + z**2)
+    phi = np.arctan2(y+1e-10, x)
+    theta = np.where( np.isclose(r, 0.0), np.zeros_like(r), np.arccos(z/r) )
+    return r,phi,theta

quplots-0.0.1/src/quplots/electron/electron.py

@@ -0,0 +1,46 @@
+import numpy as np
+from .coordinates import Cartesian_definition, CartesianToSpherical
+from .radial import radial
+from .sphericalHarmonics import RealSpherical, ImaginarySpherical
+from .waveFunction import normalized_wf, normalized_wf3D, normalized_wf3D_complex
+class electron:
+    def __init__(self,n,l,m,radius):
+        if n <= 0 or l < 0 or l >= n:
+            raise ValueError(f"Valores inválidos para n y l: n={n}, l={l}")
+        if abs(m) > l:
+            raise ValueError(f"m debe estar entre -l y l: l={l}, m={m}")
+        self.n=n
+        self.l=l
+        self.m=m
+        self.radius=radius
+    def get_cartesian_grid(self):
+        return Cartesian_definition()
+
+    def get_spherical_grid(self, x, y, z):
+        return CartesianToSpherical(x, y, z)
+
+    def compute_radial(self):
+        return radial(self.radius, self.n, self.l)
+
+    def compute_real_spherical(self):
+        return RealSpherical(self.l, self.m)
+
+    def compute_imaginary_spherical(self):
+        return ImaginarySpherical(self.l, self.m)
+
+    def compute_wavefunction_2D(self, d=2000):
+        return normalized_wf(d, self.n, self.l, self.m)
+
+    def compute_wavefunction_3D(self):
+        return normalized_wf3D(self.n, self.l, self.m)
+
+    def compute_wavefunction_3D_complex(self):
+        return normalized_wf3D_complex(self.n, self.l, self.m)
+    def getN(self):
+        return self.n
+    def getL(self):
+        return self.l
+    def getM(self):
+        return self.m
+    def getRadius(self):
+        return self.radius

quplots-0.0.1/src/quplots/electron/radial.py

@@ -0,0 +1,10 @@
+import numpy as np
+from scipy.special import genlaguerre,factorial
+def radial(r,n,l):
+        if n <= 0 or l < 0 or l >= n:
+            raise ValueError("Values of n and l must be postive or being at the form of n > 0, l >= 0 y l < n",n,l)
+        a0_radius = 1
+        prefactor = np.sqrt( ((2 / n * a0_radius) ** 3 * (factorial(n - l - 1))) / (2 * n * (factorial(n + l))) )
+        laguerre = genlaguerre(n - l - 1, 2 * l + 1)
+        p = 2 * r / (n * a0_radius)
+        return  prefactor * np.exp(-p / 2) * (p ** l) * laguerre(p)

quplots-0.0.1/src/quplots/electron/sphericalHarmonics.py

@@ -0,0 +1,37 @@
+import numpy as np
+from scipy.special import sph_harm
+def RealSpherical(l,m):
+        #Creade grid of phi and theta angles for ploting surface mesh
+        phi, theta = np.linspace(0, np.pi, 100), np.linspace(0, 2*np.pi, 100)
+        phi, theta = np.meshgrid(phi, theta)
+
+        #Calcualte spherical harmonic with given m and l
+        Y = sph_harm(abs(m), l, theta, phi)
+        if m<0:
+            Y=np.sqrt(2)*(-1)**m*Y.imag
+        elif m>0:
+            Y=np.sqrt(2)*(-1)**m*Y.real
+        R=abs(Y)
+        # Let's normalize color scale
+        fcolors    = Y.real
+        fmax, fmin = fcolors.max(), fcolors.min()
+        fcolors    = (fcolors - fmin)/(fmax - fmin)
+        if m>l:
+            raise ValueError("l and m must be postive, it means, that l can't be smaller than m")
+        return R,phi,theta,fcolors,l,m
+def ImaginarySpherical(l,m):
+    #Creade grid of phi and theta angles for ploting surface mesh
+    phi, theta = np.linspace(0, np.pi, 100), np.linspace(0, 2*np.pi, 100)
+    phi, theta = np.meshgrid(phi, theta)
+
+    #Calcualte spherical harmonic with given m and l
+    Ylm = sph_harm(m, l, theta, phi)
+    R=abs(Ylm)
+
+    # Let's normalize color scale
+    fcolors    = Ylm.imag
+    fmax, fmin = fcolors.max(), fcolors.min()
+    fcolors    = (fcolors - fmin)/(fmax - fmin)
+    if m>l:
+            raise ValueError("l and m must be postive, it means, that l can't be smaller than m")
+    return R,phi,theta,fcolors,l,m

quplots-0.0.1/src/quplots/electron/waveFunction.py

@@ -0,0 +1,26 @@
+import numpy as np
+from scipy.special import sph_harm
+from .radial import radial   
+from .coordinates import * 
+def normalized_wf(d,n,l,m):
+    r     = np.linspace(0, d, 10000)
+    pr = radial(r, n, l)**2 * r**2 * (r[1]-r[0])
+    max_r = r[ np.where(np.cumsum(pr) >0.95)[0][0] ]
+    # Set coordinates grid to assign a certain probability to each point (x, y) in the plane
+    x = y = np.linspace(-max_r, max_r, 501)
+    x, y = np.meshgrid(x, y)
+    r = np.sqrt((x ** 2 + y ** 2))
+    # Ψnlm(r,θ,φ) = Rnl(r).Ylm(θ,φ)
+    psi = radial(r, n, l) * sph_harm(m, l, 0, np.arctan(x / (y + 1e-7)))
+    psi_sq = np.abs(psi)**2
+    return psi_sq,max_r,n,l,m  
+def normalized_wf3D(n,l,m):
+    x,y,z = Cartesian_definition()
+    r,phi,theta = CartesianToSpherical(x,y,z)
+    psi = radial(r, n, l) * np.real(sph_harm(m, l, phi, theta))
+    return psi
+def normalized_wf3D_complex(n,l,m):
+    x,y,z = Cartesian_definition()
+    r,phi,theta = CartesianToSpherical(x,y,z)
+    psi = radial(r, n, l) * sph_harm(m, l, phi, theta)*np.real(sph_harm(m, l, phi, theta))
+    return psi

quplots-0.0.1/src/quplots/hibrydization/hybridization.py

@@ -0,0 +1,32 @@
+from .sp import sp
+from .sp2 import sp2
+from .sp3 import sp3
+from .sp2d import sp2d
+from .sp3d import sp3d
+from .sp3d2 import sp3d2
+from .sp3d import sp3d  
+
+class hybridization:
+    def __init__(self):
+        pass
+
+    def generate_sp(self):
+        return sp()
+
+    def generate_sp2(self):
+        return sp2()
+
+    def generate_sp3(self):
+        return sp3()
+
+    def generate_sp2d(self):
+        return sp2d()
+
+    def generate_sp3d(self):
+        return sp3d()
+
+    def generate_sp3d2(self):
+        return sp3d2()
+
+    def generate_sp3d(self):
+        return sp3d()

quplots-0.0.1/src/quplots/hibrydization/sp.py

@@ -0,0 +1,8 @@
+import numpy as np
+from ..electron.waveFunction import normalized_wf3D
+def sp():
+        Spsi = normalized_wf3D(2,0,0)
+        Pzpsi= normalized_wf3D(2,1,0)
+        PSI1=1/np.sqrt(2)*(Spsi-Pzpsi)
+        PSI2=1/np.sqrt(2)*(Spsi+Pzpsi)
+        return PSI1,PSI2

quplots-0.0.1/src/quplots/hibrydization/sp2.py

@@ -0,0 +1,11 @@
+from ..electron.waveFunction import normalized_wf3D
+import numpy as np
+def sp2():
+    Spsi = normalized_wf3D(2,0,0)
+    Pxpsi= normalized_wf3D(2,1,1)
+    Pzpsi= normalized_wf3D(2,1,0)
+    Pypsi= normalized_wf3D(2,1,-1)
+    PSI2_1=1/np.sqrt(3)*(Spsi+np.sqrt(2)*Pzpsi)
+    PSI2_2=1/np.sqrt(3)*(Spsi-np.sqrt(1/2)*Pxpsi-np.sqrt(3/2)*Pzpsi)
+    PSI2_3=1/np.sqrt(3)*(Spsi-np.sqrt(1/2)*Pxpsi+np.sqrt(3/2)*Pypsi)
+    return PSI2_1,PSI2_2,PSI2_3

quplots-0.0.1/src/quplots/hibrydization/sp2d.py

@@ -0,0 +1,12 @@
+import numpy as np 
+from ..electron.waveFunction import *
+def sp2d():
+    Spsi =  normalized_wf3D(3,0,0)
+    Pxpsi=  normalized_wf3D(3,1,1)
+    Pypsi = normalized_wf3D(3,1,-1)
+    Dx2y2psi = normalized_wf3D(3,2,2)
+    PSI2D_1=1/2*Spsi+1/np.sqrt(2)*Pxpsi+1/2*Dx2y2psi
+    PSI2D_2=1/2*Spsi-1/np.sqrt(2)*Pxpsi+1/2*Dx2y2psi
+    PSI2D_3=1/2*Spsi+1/np.sqrt(2)*Pypsi-1/2*Dx2y2psi
+    PSI2D_4=1/2*Spsi-1/np.sqrt(2)*Pypsi-1/2*Dx2y2psi
+    return PSI2D_1,PSI2D_2,PSI2D_3,PSI2D_4

quplots-0.0.1/src/quplots/hibrydization/sp3.py

@@ -0,0 +1,12 @@
+import numpy as np
+from ..electron.waveFunction import *
+def sp3():
+    Pxpsi=  normalized_wf3D_complex(2,1,1)
+    Spsi =  normalized_wf3D_complex(2,0,0)
+    Pypsi = normalized_wf3D_complex(2,1,-1)
+    Pzpsi = normalized_wf3D_complex(2,1,0)
+    PSI3_1=1/2*(Spsi+Pxpsi+Pypsi+Pzpsi)
+    PSI3_2=1/2*(Spsi+Pxpsi-Pypsi-Pzpsi)
+    PSI3_3=1/2*(Spsi-Pxpsi-Pypsi+Pzpsi)
+    PSI3_4=1/2*(Spsi-Pxpsi+Pypsi-Pzpsi)
+    return PSI3_1,PSI3_2,PSI3_3,PSI3_4

quplots-0.0.1/src/quplots/hibrydization/sp3d.py

@@ -0,0 +1,14 @@
+import numpy as np
+from ..electron.waveFunction import *
+def sp3d():
+        Spsi =  normalized_wf3D(3,0,0)
+        Pxpsi=  normalized_wf3D(3,1,1)
+        Pypsi = normalized_wf3D(3,1,-1)
+        Pzpsi = normalized_wf3D(3,1,0)
+        Dz2psi = normalized_wf3D(3,2,0)
+        PSIP3D_1=np.sqrt(1/3)*(Spsi+np.sqrt(2)*Pzpsi)
+        PSIP3D_2=1/np.sqrt(3)*(Spsi-np.sqrt(1/2)*Pxpsi+np.sqrt(3/2)*Pypsi)
+        PSIP3D_3=1/np.sqrt(3)*(Spsi-np.sqrt(1/2)*Pxpsi-np.sqrt(3/2)*Pzpsi)
+        PSIP3D_4=1/np.sqrt(2)*(Dz2psi+Pzpsi)
+        PSIP3D_5=1/np.sqrt(2)*(-Dz2psi+Pzpsi)
+        return PSIP3D_1,PSIP3D_2,PSIP3D_3,PSIP3D_4,PSIP3D_5

quplots-0.0.1/src/quplots/hibrydization/sp3d2.py

@@ -0,0 +1,16 @@
+import numpy as np
+from ..electron.waveFunction import *
+def sp3d2():
+    Spsi =  normalized_wf3D(3,0,0)
+    Pxpsi=  normalized_wf3D(3,1,1)
+    Pypsi = normalized_wf3D(3,1,-1)
+    Pzpsi = normalized_wf3D(3,1,0)
+    Dz2psi = normalized_wf3D(3,2,0)
+    Dx2y2psi = normalized_wf3D(3,2,2)
+    PSIP3D2_1=np.sqrt(1/6)*(Spsi+np.sqrt(3)*Pzpsi+np.sqrt(2)*Dz2psi)
+    PSIP3D2_2=np.sqrt(1/6)*(Spsi+np.sqrt(3)*Pzpsi-np.sqrt(1/2)*Dz2psi+np.sqrt(3/2)*Dx2y2psi)
+    PSIP3D2_3=np.sqrt(1/6)*(Spsi+np.sqrt(3)*Pzpsi-np.sqrt(1/2)*Dz2psi-np.sqrt(3/2)*Dx2y2psi)
+    PSIP3D2_4=np.sqrt(1/6)*(Spsi+np.sqrt(3)*Pzpsi-np.sqrt(1/2)*Dz2psi+np.sqrt(3/2)*Dx2y2psi)
+    PSIP3D2_5=np.sqrt(1/6)*(Spsi+np.sqrt(3)*Pzpsi-np.sqrt(1/2)*Dz2psi-np.sqrt(3/2)*Dx2y2psi)
+    PSIP3D2_6=np.sqrt(1/6)*(Spsi-np.sqrt(3)*Pzpsi+np.sqrt(2)*Dz2psi)
+    return PSIP3D2_1,PSIP3D2_2,PSIP3D2_3,PSIP3D2_4,PSIP3D2_5,PSIP3D2_6

quplots-0.0.1/src/quplots/plots/plots.py

@@ -0,0 +1,421 @@
+import numpy as np
+import  matplotlib.pyplot as plt
+import plotly.graph_objects as go 
+from ..electron.electron import electron
+from scipy.special import sph_harm, genlaguerre, factorial
+from ..electron.radial import radial
+from ..electron.coordinates import *
+from ..hibrydization.sp import sp
+from ..hibrydization.sp2 import sp2
+from ..hibrydization.sp3 import sp3
+from ..hibrydization.sp2d import sp2d
+from ..hibrydization.sp3d import sp3d
+from ..hibrydization.sp3d2 import sp3d2
+from ..hibrydization.sp3d import sp3d  
+class plots:
+    def __init__(self, *args):
+        super(plots, self).__init__(*args)
+    def plot_radial_(self,elect=None,d=None,n=None,l=None,**plot_kwargs):
+        if elect is not None and isinstance(elect,electron):
+            d=elect.getRadius()
+            r=np.linspace(0,d,1000)
+            R_function=radial(r,elect.getN(),elect.getL())
+        else:
+            r = np.linspace(0, d, 1000)
+            R_function = radial(r, n, l)
+        plt.plot(r, r**2 * R_function**2,**plot_kwargs)
+        plt.title(f'$R_{{n, l}}(r)$ distancia = {d}')
+        plt.xlabel(r'$r [a_0]$')
+        plt.ylabel(r'$R_nl(r) r^2$')
+        plt.show()
+    def plot_spherical_real(self,elect=None,R=None,theta=None,phi=None,fcolors=None,l=None,m=None,**plots_kwargs):
+        if elect is not None and isinstance(elect,electron):
+            package=elect.compute_real_spherical()
+            x=package[0]*np.sin(package[1]) * np.cos(package[2])
+            y=package[0]*np.sin(package[1]) * np.sin(package[2])
+            z=package[0]*np.cos(package[1])
+            surfacecolor=package[3]
+            l_val,m_val=package[4],package[5]
+        else:
+            x=R*np.sin(theta) * np.cos(phi)
+            y=R*np.sin(theta) * np.sin(phi)
+            z=R*np.cos(theta)
+            surfacecolor=fcolors
+            l_val,m_val=l,m
+        surface_args = {
+            "x": x,
+            "y": y,
+            "z": z,
+            "surfacecolor": surfacecolor,
+            "colorscale": plots_kwargs.pop("colorscale", "balance"),
+            "showscale": plots_kwargs.pop("showscale", False)
+        }
+        fig=go.Figure(data=[go.Surface(**surface_args)])
+        layout_args = {
+            "title": plots_kwargs.pop("title", f"<b>Y<sub>{l_val},{m_val}</sub></b>"),
+            "autosize": plots_kwargs.pop("autosize", False),
+            "width": plots_kwargs.pop("width", 700),
+            "height": plots_kwargs.pop("height", 700),
+            "margin": plots_kwargs.pop("margin", dict(l=65, r=50, b=65, t=90)),
+            "paper_bgcolor": plots_kwargs.pop("paper_bgcolor", "black"),
+            "scene": plots_kwargs.pop("scene", dict(
+                xaxis=dict(visible=False),
+                yaxis=dict(visible=False),
+                zaxis=dict(visible=False))),
+            "font": plots_kwargs.pop("font", dict(color="white"))
+        }
+        fig.update_layout(**layout_args,**plots_kwargs)
+        fig.show()
+    def plot_spherical_imaginary(self,elect=None,R=None,theta=None,phi=None,fcolors=None,l=None,m=None,**plots_kwargs):
+        if elect is not None and isinstance(elect,electron):
+            package=elect.compute_imaginary_spherical()
+            x=package[0]*np.sin(package[1]) * np.cos(package[2])
+            y=package[0]*np.sin(package[1]) * np.sin(package[2])
+            z=package[0]*np.cos(package[1])
+            surfacecolor=package[3]
+            l_val,m_val=package[4],package[5]
+        else:
+            x=R*np.sin(phi) * np.cos(theta)
+            y=R*np.sin(phi) * np.sin(theta)
+            z=R*np.cos(phi)
+            surfacecolor=fcolors
+            l_val,m_val=l,m
+        surface_args = {
+            "x": x,
+            "y": y,
+            "z": z,
+            "surfacecolor": surfacecolor,
+            "colorscale": plots_kwargs.pop("colorscale", "balance"),
+            "showscale": plots_kwargs.pop("showscale", False)
+        }
+        fig=go.Figure(data=[go.Surface(**surface_args)])
+        layout_args = {
+            "title": plots_kwargs.pop("title", f"<b>Y<sub>{l_val},{m_val}</sub></b>"),
+            "autosize": plots_kwargs.pop("autosize", False),
+            "width": plots_kwargs.pop("width", 700),
+            "height": plots_kwargs.pop("height", 700),
+            "margin": plots_kwargs.pop("margin", dict(l=65, r=50, b=65, t=90)),
+            "paper_bgcolor": plots_kwargs.pop("paper_bgcolor", "black"),
+            "scene": plots_kwargs.pop("scene", dict(
+                xaxis=dict(visible=False),
+                yaxis=dict(visible=False),
+                zaxis=dict(visible=False))),
+            "font": plots_kwargs.pop("font", dict(color="white"))
+        }
+        fig.update_layout(**layout_args,**plots_kwargs)
+        fig.show()
+    def plot_wf_2d(self,elect=None,psi_sq=None,max_r=None,n=None,l=None,m=None,**plot_kwargs):
+        fig, ax = plt.subplots()
+        package=elect.compute_wavefunction_2D() if(elect is not None and isinstance(elect,electron)) else (psi_sq,max_r,n,l,m) 
+        levels = plot_kwargs.pop("levels", 40)
+        cmap = plot_kwargs.pop("cmap", "RdBu")
+        title_fontsize = plot_kwargs.pop("title_fontsize", 15)
+        xlabel = plot_kwargs.pop("xlabel", r"$x$")
+        ylabel = plot_kwargs.pop("ylabel", r"$y$")
+        title = plot_kwargs.pop("title", r"$|\psi_{{({0}, {1}, {2})}}|^2$".format(package[2], package[3], package[4]))
+        ax.contour(package[0], levels=levels, cmap=cmap, extent=[-package[1], package[1], -package[1], package[1]], **plot_kwargs)
+        ax.set_title(title, fontsize=title_fontsize)
+        ax.set_aspect("equal")
+        ax.set_xlabel(xlabel)
+        ax.set_ylabel(ylabel)
+        ax.set_xlim(-package[1], package[1])
+        ax.set_ylim(-package[1], package[1])
+        plt.show()
+    def plot_wf_3d(self,elect,**kwargs_plot):
+        psi= elect.compute_wavefunction_3D() if elect is not None and isinstance(elect,electron) else elect
+        x,y,z = Cartesian_definition()
+        isosurface_keys = {
+        "x", "y", "z", "value", "isomin", "isomax", "opacity", "surface_count", 
+        "caps", "colorscale", "lighting", "lightposition", "reversescale", 
+        "showscale", "name", "hoverinfo"
+        }
+        isosurface_kwargs = {k: v for k, v in kwargs_plot.items() if k in isosurface_keys}
+        layout_kwargs = {k: v for k, v in kwargs_plot.items() if k not in isosurface_keys}
+
+        fig = go.Figure(data=go.Isosurface(
+            x=x.flatten(),
+            y=y.flatten(),
+            z=z.flatten(),
+            value=abs(psi).flatten(),
+            isomin=isosurface_kwargs.pop('isomin', -0.75 * abs(psi).min()),
+            isomax=isosurface_kwargs.pop('isomax', 0.75 * abs(psi).max()),
+            opacity=isosurface_kwargs.pop('opacity', 0.5),
+            surface_count=isosurface_kwargs.pop('surface_count', 6),
+            caps=isosurface_kwargs.pop('caps', dict(x_show=False, y_show=False, z_show=False)),
+            colorscale=isosurface_kwargs.pop('colorscale', 'RdBu'),
+            **isosurface_kwargs
+        ))
+
+        n_val,l_val,m_val=elect.getN(),elect.getL(),elect.getM()
+        fig.update_layout(
+            title = f"<b>|ψ<sub>{n_val},{l_val},{m_val}</sub>(x,y,z)|</b>",
+            paper_bgcolor="black",
+            scene=dict(
+                xaxis=dict(visible=False),
+                yaxis=dict(visible=False),
+                zaxis=dict(visible=False)
+            ),
+            font=dict(color="white"),
+            **layout_kwargs
+        )
+        fig.show()
+    def plot_sp(self, **kwargs):
+        PSI1, PSI2 = sp()
+        x, y, z = Cartesian_definition()
+        isosurface_keys = {
+            "colorscale", "isomin", "isomax", "opacity", "surface_count",
+            "caps", "lighting", "lightposition", "reversescale",
+            "showscale", "name", "hoverinfo"
+        }
+        isosurface_kwargs = {k: v for k, v in kwargs.items() if k in isosurface_keys}
+        layout_kwargs = {k: v for k, v in kwargs.items() if k not in isosurface_keys}
+        opacity = isosurface_kwargs.pop("opacity", 0.5)
+        surface_count = isosurface_kwargs.pop("surface_count", 6)
+        isomin_user = isosurface_kwargs.pop("isomin", None)
+        isomax_user = isosurface_kwargs.pop("isomax", None)
+        fig = go.Figure()
+        for psi in [PSI1, PSI2]:
+            psi_abs = abs(psi)
+            isomin = isomin_user if isomin_user is not None else -0.75 * psi_abs.min()
+            isomax = isomax_user if isomax_user is not None else 0.75 * psi_abs.max()
+            fig.add_trace(go.Isosurface(
+                x=x.flatten(),
+                y=y.flatten(),
+                z=z.flatten(),
+                value=psi_abs.flatten(),
+                isomin=isomin,
+                isomax=isomax,
+                surface_count=surface_count,
+                opacity=opacity,
+                caps=dict(x_show=False, y_show=False, z_show=False),
+                **isosurface_kwargs
+            ))
+
+        fig.update_layout(
+            title=layout_kwargs.get("title", "<b>sp: Lineal</b>"),
+            paper_bgcolor=layout_kwargs.get('paper_bgcolor', "black"),
+            scene=layout_kwargs.get('scene', dict(
+                xaxis=dict(visible=False),
+                yaxis=dict(visible=False),
+                zaxis=dict(visible=False)
+            )),
+            font=layout_kwargs.get('font', dict(color="white")),
+            **{k: v for k, v in layout_kwargs.items() if k not in ['title', 'paper_bgcolor', 'scene', 'font']}
+        )
+
+        fig.show()
+    def plot_sp2(self, **kwargs):
+        PSI2_1, PSI2_2, PSI2_3 = sp2()
+        x, y, z = Cartesian_definition()
+        isosurface_keys = {
+            "colorscale", "isomin", "isomax", "opacity", "surface_count",
+            "caps", "lighting", "lightposition", "reversescale",
+            "showscale", "name", "hoverinfo"
+        }
+        isosurface_kwargs = {k: v for k, v in kwargs.items() if k in isosurface_keys}
+        layout_kwargs = {k: v for k, v in kwargs.items() if k not in isosurface_keys}
+        opacity = isosurface_kwargs.pop("opacity", 0.5)
+        surface_count = isosurface_kwargs.pop("surface_count", 6)
+        isomin_user = isosurface_kwargs.pop("isomin", None)
+        isomax_user = isosurface_kwargs.pop("isomax", None)
+        fig = go.Figure()
+        for psi in [PSI2_1, PSI2_2, PSI2_3]:
+            psi_abs = abs(psi)
+            isomin = isomin_user if isomin_user is not None else -0.75 * psi_abs.min()
+            isomax = isomax_user if isomax_user is not None else 0.75 * psi_abs.max()
+            fig.add_trace(go.Isosurface(
+                x=x.flatten(),
+                y=y.flatten(),
+                z=z.flatten(),
+                value=psi_abs.flatten(),
+                isomin=isomin,
+                isomax=isomax,
+                surface_count=surface_count,
+                opacity=opacity,
+                caps=dict(x_show=False, y_show=False, z_show=False),
+                **isosurface_kwargs
+            ))
+        fig.update_layout(
+            title=layout_kwargs.get("title", "<b>sp<sup>2</sup>: Trigonal Planar</b>"),
+            paper_bgcolor=layout_kwargs.get('paper_bgcolor', "black"),
+            scene=layout_kwargs.get('scene', dict(
+                xaxis=dict(visible=False),
+                yaxis=dict(visible=False),
+                zaxis=dict(visible=False)
+            )),
+            font=layout_kwargs.get('font', dict(color="white")),
+            **{k: v for k, v in layout_kwargs.items() if k not in ['title', 'paper_bgcolor', 'scene', 'font']}
+        )
+        fig.show()    
+    def plot_sp3(self, **kwargs):
+        PSI3_1, PSI3_2, PSI3_3, PSI3_4 = sp3()
+        x, y, z = Cartesian_definition()
+        isosurface_keys = {
+            "colorscale", "isomin", "isomax", "opacity", "surface_count",
+            "caps", "lighting", "lightposition", "reversescale",
+            "showscale", "name", "hoverinfo"
+        }
+        isosurface_kwargs = {k: v for k, v in kwargs.items() if k in isosurface_keys}
+        layout_kwargs = {k: v for k, v in kwargs.items() if k not in isosurface_keys}
+        opacity = isosurface_kwargs.pop("opacity", 0.5)
+        surface_count = isosurface_kwargs.pop("surface_count", 6)
+        isomin_user = isosurface_kwargs.pop("isomin", None)
+        isomax_user = isosurface_kwargs.pop("isomax", None)
+        fig = go.Figure()
+        for psi in [PSI3_1, PSI3_2, PSI3_3, PSI3_4]:
+            psi_abs = abs(psi)
+            isomin = isomin_user if isomin_user is not None else -0.75 * psi_abs.min()
+            isomax = isomax_user if isomax_user is not None else 0.75 * psi_abs.max()
+            fig.add_trace(go.Isosurface(
+                x=x.flatten(),
+                y=y.flatten(),
+                z=z.flatten(),
+                value=psi_abs.flatten(),
+                isomin=isomin,
+                isomax=isomax,
+                surface_count=surface_count,
+                opacity=opacity,
+                caps=dict(x_show=False, y_show=False, z_show=False),
+                **isosurface_kwargs
+            ))
+        fig.update_layout(
+            title=layout_kwargs.get("title", "<b>sp<sup>3</sup>: Tetrahedral</b>"),
+            paper_bgcolor=layout_kwargs.get('paper_bgcolor', "black"),
+            scene=layout_kwargs.get('scene', dict(
+                xaxis=dict(visible=False),
+                yaxis=dict(visible=False),
+                zaxis=dict(visible=False)
+            )),
+            font=layout_kwargs.get('font', dict(color="white")),
+            **{k: v for k, v in layout_kwargs.items() if k not in ['title', 'paper_bgcolor', 'scene', 'font']}
+        )
+        fig.show()
+    def plot_sp2d(self, **kwargs):
+        PSI2D_1, PSI2D_2, PSI2D_3, PSI2D_4 = sp2d()
+        x, y, z = Cartesian_definition()
+        isosurface_keys = {
+            "colorscale", "isomin", "isomax", "opacity", "surface_count",
+            "caps", "lighting", "lightposition", "reversescale",
+            "showscale", "name", "hoverinfo"
+        }
+        isosurface_kwargs = {k: v for k, v in kwargs.items() if k in isosurface_keys}
+        layout_kwargs = {k: v for k, v in kwargs.items() if k not in isosurface_keys}
+        opacity = isosurface_kwargs.pop("opacity", 0.5)
+        surface_count = isosurface_kwargs.pop("surface_count", 6)
+        isomin_user = isosurface_kwargs.pop("isomin", None)
+        isomax_user = isosurface_kwargs.pop("isomax", None)
+        fig = go.Figure()
+        for psi in [PSI2D_1, PSI2D_2, PSI2D_3, PSI2D_4]:
+            psi_abs = abs(psi)
+            isomin = isomin_user if isomin_user is not None else -0.75 * psi_abs.min()
+            isomax = isomax_user if isomax_user is not None else 0.75 * psi_abs.max()
+            fig.add_trace(go.Isosurface(
+                x=x.flatten(),
+                y=y.flatten(),
+                z=z.flatten(),
+                value=psi_abs.flatten(),
+                isomin=isomin,
+                isomax=isomax,
+                surface_count=surface_count,
+                opacity=opacity,
+                caps=dict(x_show=False, y_show=False, z_show=False),
+                **isosurface_kwargs
+            ))
+        fig.update_layout(
+            title=layout_kwargs.get("title", "<b>sp<sup>2</sup>d: Square Planar</b>"),
+            paper_bgcolor=layout_kwargs.get('paper_bgcolor', "black"),
+            scene=layout_kwargs.get('scene', dict(
+                xaxis=dict(visible=False),
+                yaxis=dict(visible=False),
+                zaxis=dict(visible=False)
+            )),
+            font=layout_kwargs.get('font', dict(color="white")),
+            **{k: v for k, v in layout_kwargs.items() if k not in ['title', 'paper_bgcolor', 'scene', 'font']}
+        )
+        fig.show()
+    def plot_sp3d(self, **kwargs): 
+        PSIP3D_1, PSIP3D_2, PSIP3D_3, PSIP3D_4, PSIP3D_5 = sp3d()
+        x, y, z = Cartesian_definition()
+        isosurface_keys = {
+            "colorscale", "isomin", "isomax", "opacity", "surface_count",
+            "caps", "lighting", "lightposition", "reversescale",
+            "showscale", "name", "hoverinfo"
+        }
+        isosurface_kwargs = {k: v for k, v in kwargs.items() if k in isosurface_keys}
+        layout_kwargs = {k: v for k, v in kwargs.items() if k not in isosurface_keys}
+        opacity = isosurface_kwargs.pop("opacity", 0.5)
+        surface_count = isosurface_kwargs.pop("surface_count", 6)
+        isomin_user = isosurface_kwargs.pop("isomin", None)
+        isomax_user = isosurface_kwargs.pop("isomax", None)
+        fig = go.Figure()
+        for psi in [PSIP3D_1, PSIP3D_2, PSIP3D_3, PSIP3D_4, PSIP3D_5]:    
+            psi_abs = abs(psi)
+            isomin = isomin_user if isomin_user is not None else -0.75 * psi_abs.min()
+            isomax = isomax_user if isomax_user is not None else 0.75 * psi_abs.max()
+            fig.add_trace(go.Isosurface(
+                x=x.flatten(),
+                y=y.flatten(),
+                z=z.flatten(),
+                value=psi_abs.flatten(),
+                isomin=isomin,
+                isomax=isomax,
+                surface_count=surface_count,
+                opacity=opacity,
+                caps=dict(x_show=False, y_show=False, z_show=False),
+                **isosurface_kwargs
+            ))
+        fig.update_layout(
+            title=layout_kwargs.get("title", "<b>sp<sup>3</sup>d: Trigonal Bipyramidal</b>"),
+            paper_bgcolor=layout_kwargs.get('paper_bgcolor', "black"),
+            scene=layout_kwargs.get('scene', dict(
+                xaxis=dict(visible=False),
+                yaxis=dict(visible=False),
+                zaxis=dict(visible=False)
+            )),
+            font=layout_kwargs.get('font', dict(color="white")),
+            **{k: v for k, v in layout_kwargs.items() if k not in ['title', 'paper_bgcolor', 'scene', 'font']}
+        )
+        fig.show()
+    def plot_sp3d2(self, **kwargs):
+        PSIP3D2_1, PSIP3D2_2, PSIP3D2_3, PSIP3D2_4, PSIP3D2_5, PSIP3D2_6 = sp3d2()
+        x, y, z = Cartesian_definition()
+        isosurface_keys = {
+            "colorscale", "isomin", "isomax", "opacity", "surface_count",
+            "caps", "lighting", "lightposition", "reversescale",
+            "showscale", "name", "hoverinfo"
+        }
+        isosurface_kwargs = {k: v for k, v in kwargs.items() if k in isosurface_keys}
+        layout_kwargs = {k: v for k, v in kwargs.items() if k not in isosurface_keys}
+        opacity = isosurface_kwargs.pop("opacity", 0.5)
+        surface_count = isosurface_kwargs.pop("surface_count", 6)
+        isomin_user = isosurface_kwargs.pop("isomin", None)
+        isomax_user = isosurface_kwargs.pop("isomax", None)
+        fig = go.Figure()
+        for psi in [PSIP3D2_1, PSIP3D2_2, PSIP3D2_3, PSIP3D2_4, PSIP3D2_5, PSIP3D2_6]:
+            psi_abs = abs(psi)
+            isomin = isomin_user if isomin_user is not None else -0.75 * psi_abs.min()
+            isomax = isomax_user if isomax_user is not None else 0.75 * psi_abs.max()
+            fig.add_trace(go.Isosurface(
+                x=x.flatten(),
+                y=y.flatten(),
+                z=z.flatten(),
+                value=psi_abs.flatten(),
+                isomin=isomin,
+                isomax=isomax,
+                surface_count=surface_count,
+                opacity=opacity,
+                caps=dict(x_show=False, y_show=False, z_show=False),
+                **isosurface_kwargs
+            ))
+        fig.update_layout(
+            title=layout_kwargs.get("title", "<b>sp<sup>3</sup>d<sup>2</sup>: Octahedral</b>"),
+            paper_bgcolor=layout_kwargs.get('paper_bgcolor', "black"),
+            scene=layout_kwargs.get('scene', dict(
+                xaxis=dict(visible=False),
+                yaxis=dict(visible=False),
+                zaxis=dict(visible=False)
+            )),
+            font=layout_kwargs.get('font', dict(color="white")),
+            **{k: v for k, v in layout_kwargs.items() if k not in ['title', 'paper_bgcolor', 'scene', 'font']}
+        )
+        fig.show()

quplots-0.0.1/tests/__init__.py

@@ -0,0 +1,3 @@
+# SPDX-FileCopyrightText: 2025-present Adrian <kerpador@gmail.com>
+#
+# SPDX-License-Identifier: MIT

quplots-0.0.1/tests/test.py

@@ -0,0 +1,37 @@
+from quplots import plots
+p = plots()
+p.plot_sp(
+    colorscale='Viridis',
+    reversescale=True,
+    opacity=0.6,
+    surface_count=5,
+    lighting=dict(ambient=0.4, diffuse=0.9, specular=0.5, roughness=0.9, fresnel=0.1),
+    lightposition=dict(x=100, y=200, z=0),
+    showscale=False,
+    name="Orbital"
+)
+
+p.plot_sp2(colorscale='Plasma',
+            reversescale=False,
+            opacity=0.7,
+            surface_count=5)
+
+p.plot_sp3(colorscale='Cividis',
+           reversescale=False,
+           opacity=0.7,
+           surface_count=5)
+
+p.plot_sp2d(colorscale='Inferno',
+            reversescale=False,
+            opacity=0.7,
+            surface_count=5)
+
+p.plot_sp3d(colorscale='Magma',
+            reversescale=False,
+            opacity=0.7,
+            surface_count=5)
+
+p.plot_sp3d2(colorscale='Turbo',
+             reversescale=False,
+             opacity=0.7,
+             surface_count=5)