qthinking 0.0.2__tar.gz → 0.0.3__tar.gz

qthinking-0.0.3/PKG-INFO

@@ -0,0 +1,190 @@
+Metadata-Version: 2.4
+Name: qthinking
+Version: 0.0.3
+Summary: Buchow quantum simulator
+Author: buchowatom
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: matplotlib>=3.11.2
+Requires-Dist: numpy>=2.5.4
+Requires-Dist: qutip>=5.3.1
+Requires-Dist: scikit-learn>=1.9.1
+Requires-Dist: scipy>=1.18.1
+Requires-Dist: setuptools>=84.2.1
+Requires-Dist: twine>=7.0.0
+Dynamic: author
+Dynamic: license-file
+
+# Quantum Analog SDK
+
+A Python SDK for neutral-atom quantum analog computing, simulation, and quantum reservoir computing.
+
+## Overview
+
+**Quantum Analog SDK (`qthinking`)** provides a Python interface for modeling and simulating neutral-atom quantum systems. It offers a unified API for defining analog programs, configuring time-dependent control parameters, specifying observables, executing simulations, and analyzing results.
+
+The SDK is designed for quantum computing research, simulation workflows, and integration into quantum computing applications. It also provides quantum machine learning components, including quantum extreme learning and quantum reservoir computing workflows.
+
+## Features
+
+- **Analog Program Modeling** — Define neutral-atom systems, Rydberg Hamiltonians, initial states, and evolution parameters.
+- **Pulse and Waveform Configuration** — Configure Rabi amplitude, phase, detuning, and supported time-dependent waveforms.
+- **Observable Configuration** — Evaluate expectation values of observables such as \(X\), \(Y\), \(Z\), \(ZZ\), and Rydberg-state occupation.
+- **Local Simulation** — Execute analog programs using the QuTiP simulation backend or the supported NumPy split-step backend.
+- **Simulation Results** — Retrieve evolution times, observable expectation values, final states, and measurement results when requested.
+- **Neutral-Atom System Support** — Model atom arrangements and configure interaction parameters, with additional helpers for Rb-87 systems.
+- **Quantum Machine Learning** — Explore quantum extreme learning (QELM), quantum reservoir computing (QRC), and classical readout models.
+
+## Installation
+
+Install `qthinking` from PyPI:
+
+```bash
+python -m pip install qthinking
+```
+
+The package requires **Python 3.12 or later**. Its declared dependencies are installed automatically by `pip`.
+
+To verify the installation:
+
+```bash
+python -c "import qthinking; print('qthinking installed successfully')"
+```
+
+## Quick Start
+
+This example demonstrates how to define a two-atom Rydberg analog program, execute a local simulation, and inspect the results.
+
+### 1. Create an Analog Program
+
+```python
+from qthinking.analog import rydberg_program
+from qthinking.backends import QutipBackend
+
+# Define a two-atom Rydberg system.
+program = rydberg_program(
+    n_atoms=2,
+    rabi_amplitude=2.0,
+    rabi_phase=0.0,
+    detuning=1.0,
+    interaction=3.0,
+    duration_us=1.0,
+    observables=("Z", "occupation"),
+    n_virtual_nodes=10,
+    return_final_state=True,
+)
+
+# Execute the program using the QuTiP backend.
+backend = QutipBackend()
+result = backend.run(program)
+```
+
+The `rydberg_program()` function creates an analog program with constant control parameters unless waveforms are explicitly provided.
+
+In this example:
+
+- `n_atoms` specifies the number of atoms.
+- `rabi_amplitude` and `rabi_phase` configure the driving field.
+- `detuning` specifies the detuning parameter.
+- `interaction` defines the pairwise interaction strength.
+- `duration_us` sets the evolution duration in microseconds.
+- `observables` selects the quantities to evaluate.
+- `n_virtual_nodes` requests measurements at uniformly spaced evolution times.
+- `return_final_state=True` requests the final quantum state.
+
+Frequency and interaction parameters use the SDK's angular-frequency convention (`rad/us`), while evolution time is measured in microseconds.
+
+### 2. Inspect the Simulation Results
+
+```python
+# Print the simulation backend.
+print("Backend:", result.metadata["backend"])
+
+# Retrieve the evolution times.
+print("Evolution times (us):", result.times_us)
+
+# Retrieve observable expectation values.
+print("Z expectation values for atom 0:")
+print(result.expectations["Z_0"])
+
+print("Rydberg occupation for atom 0:")
+print(result.expectations["N_0"])
+
+# Retrieve the final density matrix.
+if result.final_state is not None:
+    print("Final state:")
+    print(result.final_state)
+```
+
+The simulation result provides:
+
+- **`result.times_us`** — The evolution times at which measurements are evaluated.
+- **`result.expectations`** — A mapping from observable names to their time-dependent expectation values, such as `Z_0`, `Z_1`, `N_0`, and `N_1`.
+- **`result.final_state`** — The final quantum state when requested.
+- **`result.metadata`** — Execution metadata, including the backend name.
+
+### 3. Visualize the Results
+
+The simulation result also provides a plotting method for inspecting observable trajectories.
+
+```python
+# Plot all available expectation-value trajectories.
+fig = result.show()
+
+# Save the figure.
+fig.savefig("analog_simulation_results.png", dpi=150)
+```
+
+This provides a convenient way to inspect the evolution of the selected observables.
+
+## Typical Workflow
+
+A typical analog simulation workflow consists of the following steps:
+
+1. Define the neutral-atom system and interaction parameters.
+2. Configure the driving fields and evolution duration.
+3. Select the observables and measurement times.
+4. Execute the program using a compatible simulation backend.
+5. Analyze the resulting expectation values and final quantum state.
+
+## Supported Capabilities
+
+The SDK provides components for the following workflows:
+
+- **Analog Simulation:** Construct and execute neutral-atom analog programs.
+- **Control Configuration:** Configure constant controls and supported waveform types, including linear and Blackman waveforms.
+- **Observable Evaluation:** Evaluate single-atom and pairwise observables, as supported by the selected program and backend.
+- **Simulation Backends:** Run programs using QuTiP or the supported NumPy split-step implementation.
+- **Rb-87 Modeling:** Use the available Rb-87 program helpers and triangular-array models.
+- **Quantum Machine Learning:** Build QELM and QRC workflows and use classical machine learning readout models.
+
+Backend support depends on the program configuration. For example, the NumPy split-step backend supports a more restricted set of programs than the QuTiP backend.
+
+## Requirements
+
+- **Python:** 3.12 or later.
+- **Dependencies:** Installed automatically through `pip`.
+- **Execution environment:** A local Python environment for running supported simulations.
+- **Remote quantum devices:** Hardware execution requires a compatible backend integration. Installing the SDK alone does not establish access to a remote quantum device.
+
+## Documentation
+
+For more information, explore the package modules and examples in this repository:
+
+- `qthinking.analog` — Analog program construction, controls, waveforms, systems, and observables.
+- `qthinking.backends` — Simulation backend implementations.
+- `qthinking.qelm` — Quantum extreme learning components.
+- `qthinking.qrc` — Quantum reservoir computing components.
+- `qthinking.ml` — Classical machine learning models.
+- `qthinking.applications` — Application-oriented examples and workflows.
+
+## License
+
+Copyright (c) 2018 Python Packaging Authority
+
+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.

qthinking-0.0.3/README.md

@@ -0,0 +1,172 @@
+# Quantum Analog SDK
+
+A Python SDK for neutral-atom quantum analog computing, simulation, and quantum reservoir computing.
+
+## Overview
+
+**Quantum Analog SDK (`qthinking`)** provides a Python interface for modeling and simulating neutral-atom quantum systems. It offers a unified API for defining analog programs, configuring time-dependent control parameters, specifying observables, executing simulations, and analyzing results.
+
+The SDK is designed for quantum computing research, simulation workflows, and integration into quantum computing applications. It also provides quantum machine learning components, including quantum extreme learning and quantum reservoir computing workflows.
+
+## Features
+
+- **Analog Program Modeling** — Define neutral-atom systems, Rydberg Hamiltonians, initial states, and evolution parameters.
+- **Pulse and Waveform Configuration** — Configure Rabi amplitude, phase, detuning, and supported time-dependent waveforms.
+- **Observable Configuration** — Evaluate expectation values of observables such as \(X\), \(Y\), \(Z\), \(ZZ\), and Rydberg-state occupation.
+- **Local Simulation** — Execute analog programs using the QuTiP simulation backend or the supported NumPy split-step backend.
+- **Simulation Results** — Retrieve evolution times, observable expectation values, final states, and measurement results when requested.
+- **Neutral-Atom System Support** — Model atom arrangements and configure interaction parameters, with additional helpers for Rb-87 systems.
+- **Quantum Machine Learning** — Explore quantum extreme learning (QELM), quantum reservoir computing (QRC), and classical readout models.
+
+## Installation
+
+Install `qthinking` from PyPI:
+
+```bash
+python -m pip install qthinking
+```
+
+The package requires **Python 3.12 or later**. Its declared dependencies are installed automatically by `pip`.
+
+To verify the installation:
+
+```bash
+python -c "import qthinking; print('qthinking installed successfully')"
+```
+
+## Quick Start
+
+This example demonstrates how to define a two-atom Rydberg analog program, execute a local simulation, and inspect the results.
+
+### 1. Create an Analog Program
+
+```python
+from qthinking.analog import rydberg_program
+from qthinking.backends import QutipBackend
+
+# Define a two-atom Rydberg system.
+program = rydberg_program(
+    n_atoms=2,
+    rabi_amplitude=2.0,
+    rabi_phase=0.0,
+    detuning=1.0,
+    interaction=3.0,
+    duration_us=1.0,
+    observables=("Z", "occupation"),
+    n_virtual_nodes=10,
+    return_final_state=True,
+)
+
+# Execute the program using the QuTiP backend.
+backend = QutipBackend()
+result = backend.run(program)
+```
+
+The `rydberg_program()` function creates an analog program with constant control parameters unless waveforms are explicitly provided.
+
+In this example:
+
+- `n_atoms` specifies the number of atoms.
+- `rabi_amplitude` and `rabi_phase` configure the driving field.
+- `detuning` specifies the detuning parameter.
+- `interaction` defines the pairwise interaction strength.
+- `duration_us` sets the evolution duration in microseconds.
+- `observables` selects the quantities to evaluate.
+- `n_virtual_nodes` requests measurements at uniformly spaced evolution times.
+- `return_final_state=True` requests the final quantum state.
+
+Frequency and interaction parameters use the SDK's angular-frequency convention (`rad/us`), while evolution time is measured in microseconds.
+
+### 2. Inspect the Simulation Results
+
+```python
+# Print the simulation backend.
+print("Backend:", result.metadata["backend"])
+
+# Retrieve the evolution times.
+print("Evolution times (us):", result.times_us)
+
+# Retrieve observable expectation values.
+print("Z expectation values for atom 0:")
+print(result.expectations["Z_0"])
+
+print("Rydberg occupation for atom 0:")
+print(result.expectations["N_0"])
+
+# Retrieve the final density matrix.
+if result.final_state is not None:
+    print("Final state:")
+    print(result.final_state)
+```
+
+The simulation result provides:
+
+- **`result.times_us`** — The evolution times at which measurements are evaluated.
+- **`result.expectations`** — A mapping from observable names to their time-dependent expectation values, such as `Z_0`, `Z_1`, `N_0`, and `N_1`.
+- **`result.final_state`** — The final quantum state when requested.
+- **`result.metadata`** — Execution metadata, including the backend name.
+
+### 3. Visualize the Results
+
+The simulation result also provides a plotting method for inspecting observable trajectories.
+
+```python
+# Plot all available expectation-value trajectories.
+fig = result.show()
+
+# Save the figure.
+fig.savefig("analog_simulation_results.png", dpi=150)
+```
+
+This provides a convenient way to inspect the evolution of the selected observables.
+
+## Typical Workflow
+
+A typical analog simulation workflow consists of the following steps:
+
+1. Define the neutral-atom system and interaction parameters.
+2. Configure the driving fields and evolution duration.
+3. Select the observables and measurement times.
+4. Execute the program using a compatible simulation backend.
+5. Analyze the resulting expectation values and final quantum state.
+
+## Supported Capabilities
+
+The SDK provides components for the following workflows:
+
+- **Analog Simulation:** Construct and execute neutral-atom analog programs.
+- **Control Configuration:** Configure constant controls and supported waveform types, including linear and Blackman waveforms.
+- **Observable Evaluation:** Evaluate single-atom and pairwise observables, as supported by the selected program and backend.
+- **Simulation Backends:** Run programs using QuTiP or the supported NumPy split-step implementation.
+- **Rb-87 Modeling:** Use the available Rb-87 program helpers and triangular-array models.
+- **Quantum Machine Learning:** Build QELM and QRC workflows and use classical machine learning readout models.
+
+Backend support depends on the program configuration. For example, the NumPy split-step backend supports a more restricted set of programs than the QuTiP backend.
+
+## Requirements
+
+- **Python:** 3.12 or later.
+- **Dependencies:** Installed automatically through `pip`.
+- **Execution environment:** A local Python environment for running supported simulations.
+- **Remote quantum devices:** Hardware execution requires a compatible backend integration. Installing the SDK alone does not establish access to a remote quantum device.
+
+## Documentation
+
+For more information, explore the package modules and examples in this repository:
+
+- `qthinking.analog` — Analog program construction, controls, waveforms, systems, and observables.
+- `qthinking.backends` — Simulation backend implementations.
+- `qthinking.qelm` — Quantum extreme learning components.
+- `qthinking.qrc` — Quantum reservoir computing components.
+- `qthinking.ml` — Classical machine learning models.
+- `qthinking.applications` — Application-oriented examples and workflows.
+
+## License
+
+Copyright (c) 2018 Python Packaging Authority
+
+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.

{qthinking-0.0.2 → qthinking-0.0.3}/pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "qthinking"
-version = "0.0.2"
-description = "Add your description here"
+version = "0.0.3"
+description = "Buchow quantum simulator"
 readme = "README.md"
 requires-python = ">=3.12"
 dependencies = [

qthinking-0.0.3/qthinking.egg-info/PKG-INFO

@@ -0,0 +1,190 @@
+Metadata-Version: 2.4
+Name: qthinking
+Version: 0.0.3
+Summary: Buchow quantum simulator
+Author: buchowatom
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: matplotlib>=3.11.2
+Requires-Dist: numpy>=2.5.4
+Requires-Dist: qutip>=5.3.1
+Requires-Dist: scikit-learn>=1.9.1
+Requires-Dist: scipy>=1.18.1
+Requires-Dist: setuptools>=84.2.1
+Requires-Dist: twine>=7.0.0
+Dynamic: author
+Dynamic: license-file
+
+# Quantum Analog SDK
+
+A Python SDK for neutral-atom quantum analog computing, simulation, and quantum reservoir computing.
+
+## Overview
+
+**Quantum Analog SDK (`qthinking`)** provides a Python interface for modeling and simulating neutral-atom quantum systems. It offers a unified API for defining analog programs, configuring time-dependent control parameters, specifying observables, executing simulations, and analyzing results.
+
+The SDK is designed for quantum computing research, simulation workflows, and integration into quantum computing applications. It also provides quantum machine learning components, including quantum extreme learning and quantum reservoir computing workflows.
+
+## Features
+
+- **Analog Program Modeling** — Define neutral-atom systems, Rydberg Hamiltonians, initial states, and evolution parameters.
+- **Pulse and Waveform Configuration** — Configure Rabi amplitude, phase, detuning, and supported time-dependent waveforms.
+- **Observable Configuration** — Evaluate expectation values of observables such as \(X\), \(Y\), \(Z\), \(ZZ\), and Rydberg-state occupation.
+- **Local Simulation** — Execute analog programs using the QuTiP simulation backend or the supported NumPy split-step backend.
+- **Simulation Results** — Retrieve evolution times, observable expectation values, final states, and measurement results when requested.
+- **Neutral-Atom System Support** — Model atom arrangements and configure interaction parameters, with additional helpers for Rb-87 systems.
+- **Quantum Machine Learning** — Explore quantum extreme learning (QELM), quantum reservoir computing (QRC), and classical readout models.
+
+## Installation
+
+Install `qthinking` from PyPI:
+
+```bash
+python -m pip install qthinking
+```
+
+The package requires **Python 3.12 or later**. Its declared dependencies are installed automatically by `pip`.
+
+To verify the installation:
+
+```bash
+python -c "import qthinking; print('qthinking installed successfully')"
+```
+
+## Quick Start
+
+This example demonstrates how to define a two-atom Rydberg analog program, execute a local simulation, and inspect the results.
+
+### 1. Create an Analog Program
+
+```python
+from qthinking.analog import rydberg_program
+from qthinking.backends import QutipBackend
+
+# Define a two-atom Rydberg system.
+program = rydberg_program(
+    n_atoms=2,
+    rabi_amplitude=2.0,
+    rabi_phase=0.0,
+    detuning=1.0,
+    interaction=3.0,
+    duration_us=1.0,
+    observables=("Z", "occupation"),
+    n_virtual_nodes=10,
+    return_final_state=True,
+)
+
+# Execute the program using the QuTiP backend.
+backend = QutipBackend()
+result = backend.run(program)
+```
+
+The `rydberg_program()` function creates an analog program with constant control parameters unless waveforms are explicitly provided.
+
+In this example:
+
+- `n_atoms` specifies the number of atoms.
+- `rabi_amplitude` and `rabi_phase` configure the driving field.
+- `detuning` specifies the detuning parameter.
+- `interaction` defines the pairwise interaction strength.
+- `duration_us` sets the evolution duration in microseconds.
+- `observables` selects the quantities to evaluate.
+- `n_virtual_nodes` requests measurements at uniformly spaced evolution times.
+- `return_final_state=True` requests the final quantum state.
+
+Frequency and interaction parameters use the SDK's angular-frequency convention (`rad/us`), while evolution time is measured in microseconds.
+
+### 2. Inspect the Simulation Results
+
+```python
+# Print the simulation backend.
+print("Backend:", result.metadata["backend"])
+
+# Retrieve the evolution times.
+print("Evolution times (us):", result.times_us)
+
+# Retrieve observable expectation values.
+print("Z expectation values for atom 0:")
+print(result.expectations["Z_0"])
+
+print("Rydberg occupation for atom 0:")
+print(result.expectations["N_0"])
+
+# Retrieve the final density matrix.
+if result.final_state is not None:
+    print("Final state:")
+    print(result.final_state)
+```
+
+The simulation result provides:
+
+- **`result.times_us`** — The evolution times at which measurements are evaluated.
+- **`result.expectations`** — A mapping from observable names to their time-dependent expectation values, such as `Z_0`, `Z_1`, `N_0`, and `N_1`.
+- **`result.final_state`** — The final quantum state when requested.
+- **`result.metadata`** — Execution metadata, including the backend name.
+
+### 3. Visualize the Results
+
+The simulation result also provides a plotting method for inspecting observable trajectories.
+
+```python
+# Plot all available expectation-value trajectories.
+fig = result.show()
+
+# Save the figure.
+fig.savefig("analog_simulation_results.png", dpi=150)
+```
+
+This provides a convenient way to inspect the evolution of the selected observables.
+
+## Typical Workflow
+
+A typical analog simulation workflow consists of the following steps:
+
+1. Define the neutral-atom system and interaction parameters.
+2. Configure the driving fields and evolution duration.
+3. Select the observables and measurement times.
+4. Execute the program using a compatible simulation backend.
+5. Analyze the resulting expectation values and final quantum state.
+
+## Supported Capabilities
+
+The SDK provides components for the following workflows:
+
+- **Analog Simulation:** Construct and execute neutral-atom analog programs.
+- **Control Configuration:** Configure constant controls and supported waveform types, including linear and Blackman waveforms.
+- **Observable Evaluation:** Evaluate single-atom and pairwise observables, as supported by the selected program and backend.
+- **Simulation Backends:** Run programs using QuTiP or the supported NumPy split-step implementation.
+- **Rb-87 Modeling:** Use the available Rb-87 program helpers and triangular-array models.
+- **Quantum Machine Learning:** Build QELM and QRC workflows and use classical machine learning readout models.
+
+Backend support depends on the program configuration. For example, the NumPy split-step backend supports a more restricted set of programs than the QuTiP backend.
+
+## Requirements
+
+- **Python:** 3.12 or later.
+- **Dependencies:** Installed automatically through `pip`.
+- **Execution environment:** A local Python environment for running supported simulations.
+- **Remote quantum devices:** Hardware execution requires a compatible backend integration. Installing the SDK alone does not establish access to a remote quantum device.
+
+## Documentation
+
+For more information, explore the package modules and examples in this repository:
+
+- `qthinking.analog` — Analog program construction, controls, waveforms, systems, and observables.
+- `qthinking.backends` — Simulation backend implementations.
+- `qthinking.qelm` — Quantum extreme learning components.
+- `qthinking.qrc` — Quantum reservoir computing components.
+- `qthinking.ml` — Classical machine learning models.
+- `qthinking.applications` — Application-oriented examples and workflows.
+
+## License
+
+Copyright (c) 2018 Python Packaging Authority
+
+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.

{qthinking-0.0.2 → qthinking-0.0.3}/setup.py

@@ -21,12 +21,11 @@ setup(
     include_package_data=True,
     packages=find_packages(include=["qthinking", "qthinking.*"]),
     install_requires=[
-        'numpy>=2.2.0',
-        'scikit-learn>=1.9.1',
-        'matplotlib>=3.3.0',
-        'scipy>=1.18.1',
-        'qutip>=5.3.1',
-        'pygments'
+        "matplotlib>=3.11.2",
+        "numpy>=2.5.4",
+        "qutip>=5.3.1",
+        "scikit-learn>=1.9.1",
+        "scipy>=1.18.1",
     ],
     classifiers=[
     'Operating System :: OS Independent',

qthinking-0.0.2/PKG-INFO

@@ -1,17 +0,0 @@
-Metadata-Version: 2.4
-Name: qthinking
-Version: 0.0.2
-Summary: Add your description here
-Author: buchowatom
-Requires-Python: >=3.12
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: matplotlib>=3.11.2
-Requires-Dist: numpy>=2.5.4
-Requires-Dist: qutip>=5.3.1
-Requires-Dist: scikit-learn>=1.9.1
-Requires-Dist: scipy>=1.18.1
-Requires-Dist: setuptools>=84.2.1
-Requires-Dist: twine>=7.0.0
-Dynamic: author
-Dynamic: license-file

qthinking-0.0.2/qthinking.egg-info/PKG-INFO

@@ -1,17 +0,0 @@
-Metadata-Version: 2.4
-Name: qthinking
-Version: 0.0.2
-Summary: Add your description here
-Author: buchowatom
-Requires-Python: >=3.12
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: matplotlib>=3.11.2
-Requires-Dist: numpy>=2.5.4
-Requires-Dist: qutip>=5.3.1
-Requires-Dist: scikit-learn>=1.9.1
-Requires-Dist: scipy>=1.18.1
-Requires-Dist: setuptools>=84.2.1
-Requires-Dist: twine>=7.0.0
-Dynamic: author
-Dynamic: license-file