qilisdk 0.1.6__tar.gz → 0.1.7__tar.gz

{qilisdk-0.1.6 → qilisdk-0.1.7}/.gitignore

@@ -22,3 +22,5 @@ wheels/
 # Sphinx documentation
 docs/_build/*
 docs/code/api/*
+sphinx-verbose.log
+sphinx.log

qilisdk-0.1.7/.python-version

@@ -0,0 +1 @@
+3.13

{qilisdk-0.1.6 → qilisdk-0.1.7}/CHANGELOG.md

@@ -1,3 +1,120 @@
+# qilisdk 0.1.7 (2025-12-04)
+
+## Features
+
+- SpeQtrum's synchronous client now runs every request through a shared HTTPX client that refreshes bearer tokens automatically, ensuring submissions, listings, and polling continue seamlessly after 401s while still applying the SDK user agent. API failures now raise a dedicated SpeQtrum error that includes the message returned by the service and is logged in a human-friendly way, and job detail payloads, logs, and results are decoded defensively so malformed base64 no longer crashes the SDK. ([PR #94](https://github.com/qilimanjaro-tech/qilisdk/pulls/94))
+- Added a ``QiliSDK`` to ``OpenFermion`` converter. This allows to translate ``QubitOperator`` from ``OpenFermion`` to ``QiliSDK``'s ``Hamiltonian`` Objects and vice versa.
+
+  This optional can be installed using ``pip install qilisdk[openfermion]``.
+
+  here is an example of the usage: 
+  ```python
+  from openfermion.hamiltonians import jellium_model
+  from openfermion.transforms import fourier_transform, jordan_wigner
+  from openfermion.utils import Grid
+
+  from qilisdk.utils.openfermion import openfermion_to_qilisdk, qilisdk_to_openfermion
+
+  # Let's look at a very small model of jellium in 1D.
+  grid = Grid(dimensions=1, length=3, scale=1.0)
+  spinless = True
+
+  # Get the momentum Hamiltonian.
+  momentum_hamiltonian = jellium_model(grid, spinless)
+  momentum_qubit_operator = jordan_wigner(momentum_hamiltonian)
+  momentum_qubit_operator.compress()
+
+  # Fourier transform the Hamiltonian to the position basis.
+  position_hamiltonian = fourier_transform(momentum_hamiltonian, grid, spinless)
+  position_qubit_operator = jordan_wigner(position_hamiltonian)
+  position_qubit_operator.compress()
+
+  qilisdk_ham = openfermion_to_qilisdk(position_qubit_operator)
+  openfermion_ham = qilisdk_to_openfermion(qilisdk_ham)
+  ``` 
+  ([PR #96](https://github.com/qilimanjaro-tech/qilisdk/pulls/96))
+- Raised the SDK baseline to Python 3.11 and aligned the local version file, mypy config, CI tests, docs build, and publishing workflow up to Python 3.13. Linux and Windows installs use customized NumPy and SciPy, linked to Intel's high-performance oneAPI Math Kernel Library (Intel MKL). ([PR #99](https://github.com/qilimanjaro-tech/qilisdk/pulls/99))
+- Constraint-aware execution now threads through sampling, time evolution, variational programs, and optimizer loops, rejecting parameter sets that violate declared constraints; tests and serialization use the new APIs.
+
+  ```python
+  from qilisdk.core import GreaterThanOrEqual, Parameter
+  from qilisdk.functionals import Sampling, VariationalProgram
+
+  # Constrain theta >= phi for a variational run; violations short-circuit the optimizer step.
+  theta = Parameter("theta", 0.4, bounds=(0, 1))
+  phi = Parameter("phi", 0.3, bounds=(0, 1))
+  constraints = [GreaterThanOrEqual(theta, phi)]
+
+  vp = VariationalProgram(
+      functional=Sampling(...),
+      optimizer=...,
+      cost_function=...,
+      parameter_constraints=constraints,
+  )
+  ```
+  ([PR #100](https://github.com/qilimanjaro-tech/qilisdk/pulls/100))
+- Rebuilt analog scheduling around a single, flexible `Schedule`/`Interpolator`: `LinearSchedule` is removed, coefficients can be defined as callables or time intervals with step/linear interpolation, max-time rescaling, shared parameter tracking, and updated visualization/backends.
+
+  Centralized parameter management in `Parameterizable` so Hamiltonians, circuits, schedules, and gates all inherit consistent parameter getters/setters, constraint checking, and validation; variables add comparison helpers, caching, and math maps.
+
+  ```python
+  from qilisdk.analog import Schedule, X, Z
+  from qilisdk.analog.schedule import Interpolation
+  from qilisdk.core import Parameter
+
+  T = 10.0
+  schedule = Schedule(
+      hamiltonians={"driver": X(0), "problem": Z(0)},
+      coefficients={
+          # Interval syntax expands to sampled points; callables can reference time directly.
+          "driver": {(0, T): lambda t: 1 - t / T},
+          "problem": {(0, T): lambda t: t / T},
+      },
+      dt=0.5,
+      interpolation=Interpolation.LINEAR,
+  )
+  schedule.scale_max_time(Parameter("T_max", 8.0))
+  schedule.draw()
+  ```
+  ([PR #100](https://github.com/qilimanjaro-tech/qilisdk/pulls/100))
+- Introduced the first version of the `CircuitTranspiler` alongside the `DecomposeMultiControlledGatesPass` that decomposes any multi-controlled single-qubit gate, enabling both CUDA and QuTiP backends to execute circuits containing such constructs. The pass is wired directly into both backends today while the full transpiler pipeline is staged for future expansion. ([PR #101](https://github.com/qilimanjaro-tech/qilisdk/pulls/101))
+
+## Bugfixes
+
+- Fixed `Schedule.add_hamiltonian` so time-dependent coefficient functions populate every discrete time step.
+
+  Added regression tests to cover function-driven schedules and validate that only parameters appear in the generated coefficients. ([PR #95](https://github.com/qilimanjaro-tech/qilisdk/pulls/95))
+
+## Improved Documentation
+
+- Documentation refresh across the project:
+
+  - README now links to the hosted docs and the SpeQtrum snippet walks through building a circuit, logging in, picking a device, and submitting a `Sampling` job.
+  - Digital fundamentals gained a rendered circuit figure, QuTiP execution example for `HardwareEfficientAnsatz`, a clarified measurement note, and a new “build your own ansatz” walkthrough with code.
+  - Analog fundamentals had their operator headings cleaned up, and the shared custom CSS now ships Plus Jakarta Sans, gradient headers, and dark-mode inline-code styling; the circuit diagram image is tracked under `_static/`.
+  - The `time_evolution.ipynb` example notebook was stripped of bulky outputs/metadata to keep the repo lightweight.
+  - Installation docs call out CUDA GPU requirements and defer hands-on content to a brand-new Quickstart guide (added to the index) that hosts the digital and analog walkthroughs plus backend-specific notes.
+  - Backend fundamentals now highlight how to install optional extras and link back to the Installation guide for details.
+
+  ([PR #97](https://github.com/qilimanjaro-tech/qilisdk/pulls/97))
+- Removed `main` branch from documentation. Sorted tags by descending order. (latest is first) ([PR #104](https://github.com/qilimanjaro-tech/qilisdk/pulls/104))
+- Docs publishing now points the root of the site to the latest release docs and keeps "main" as a clearly labeled development build, with the version picker reorganized into separate Releases and Development sections so visitors land on the most current tag while still finding the dev docs easily. ([PR #109](https://github.com/qilimanjaro-tech/qilisdk/pulls/109))
+- Fixed a display bug in which inline code blocks in headers were invisible. This was due to the previous rule only accounting for "a" elements in headers and not ".pre" span elements. The reason there was a ".pre" block in the header is because of a broken class link, which will be fixed along with others in a different PR. ([PR #114](https://github.com/qilimanjaro-tech/qilisdk/pulls/114))
+- Fixed a number of broken/missing API links in the docs and in general made the docs consistent with the API reference.
+
+  Also:
+   - Remove references to optimize() since it has since been moved into execute()
+   - Fixed a broken output box
+   - Fixed several lists that weren't displaying correctly
+   - Removed an unused import from a code block in core.rst
+   - Various other typos, such as missing "a"s before certain terms (keeping consistency with previous uses of said terms)
+   - Wrapped some very long lines (as per the style throughout the rest of the files) ([PR #120](https://github.com/qilimanjaro-tech/qilisdk/pulls/120))
+
+## Misc
+
+- [PR #104](https://github.com/qilimanjaro-tech/qilisdk/pulls/104), [PR #106](https://github.com/qilimanjaro-tech/qilisdk/pulls/106)
+
+
 # qilisdk 0.1.6 (2025-10-31)
 
 ## Features

{qilisdk-0.1.6 → qilisdk-0.1.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qilisdk
-Version: 0.1.6
+Version: 0.1.7
 Summary: QiliSDK is a Python framework for writing digital and analog quantum algorithms and executing them across multiple quantum backends. Its modular design streamlines the development process and enables easy integration with a variety of quantum platforms.
 Project-URL: Homepage, https://github.com/qilimanjaro-tech/qilisdk
 Project-URL: Documentation, https://qilimanjaro-tech.github.io/qilisdk/
@@ -10,35 +10,39 @@ Project-URL: Changelog, https://github.com/qilimanjaro-tech/qilisdk/blob/main/CH
 Author-email: Qilimanjaro Quantum Tech <info@qilimanjaro.tech>
 License-File: LICENCE
 Keywords: analog quantum computing,digital quantum computing,qilimanjaro,quantum computing
-Classifier: Development Status :: 3 - Alpha
+Classifier: Development Status :: 4 - Beta
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Science/Research
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Operating System :: POSIX :: Linux
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Scientific/Engineering
 Classifier: Topic :: Scientific/Engineering :: Physics
 Classifier: Topic :: Scientific/Engineering :: Quantum Computing
-Requires-Python: >=3.10
+Requires-Python: >=3.11
 Requires-Dist: dill>=0.3.9
 Requires-Dist: loguru>=0.7.3
 Requires-Dist: matplotlib>=3.10.7
-Requires-Dist: numpy>=1.26.4
+Requires-Dist: mkl-service>=2.4.2; sys_platform != 'darwin'
+Requires-Dist: numpy>=2.2.0
 Requires-Dist: pydantic-settings>=2.11.0
 Requires-Dist: pydantic>=2.12.3
 Requires-Dist: ruamel-yaml>=0.18.16
-Requires-Dist: scipy>=1.15.3
+Requires-Dist: scipy<1.16.3,>=1.15; sys_platform != 'darwin'
+Requires-Dist: scipy>=1.16.3; sys_platform == 'darwin'
 Provides-Extra: cuda
-Requires-Dist: cuda-quantum-cu12==0.12.0.post1; extra == 'cuda'
+Requires-Dist: cuda-quantum-cu12==0.13.0; extra == 'cuda'
+Provides-Extra: openfermion
+Requires-Dist: openfermion>=1.7.1; extra == 'openfermion'
 Provides-Extra: qutip
 Requires-Dist: qutip-qip>=0.4.1; extra == 'qutip'
-Requires-Dist: qutip>=5.2.1; extra == 'qutip'
+Requires-Dist: qutip>=5.2.2; extra == 'qutip'
 Provides-Extra: speqtrum
-Requires-Dist: httpx>=0.28.1; extra == 'speqtrum'
+Requires-Dist: httpx==0.28.1; extra == 'speqtrum'
 Requires-Dist: keyring>=25.6.0; extra == 'speqtrum'
 Requires-Dist: keyrings-alt>=5.0.2; extra == 'speqtrum'
 Description-Content-Type: text/markdown
@@ -48,6 +52,7 @@ Description-Content-Type: text/markdown
 [![Python Versions](https://img.shields.io/pypi/pyversions/qilisdk.svg)](https://pypi.org/project/qilisdk/)
 [![PyPI Version](https://img.shields.io/pypi/v/qilisdk.svg)](https://pypi.org/project/qilisdk/)
 [![License](https://img.shields.io/pypi/l/qilisdk.svg)](#license)
+[![Docs](https://img.shields.io/badge/docs-latest-pink.svg)](https://qilimanjaro-tech.github.io/qilisdk/main/index.html)
 
 **QiliSDK** is a Python framework for writing digital and analog quantum algorithms and executing them across multiple quantum backends. Its modular design streamlines the development process and enables easy integration with a variety of quantum platforms.
 
@@ -202,18 +207,27 @@ print("Optimal Parameters:", result.optimal_parameters)
 QiliSDK includes a client for interacting with Qilimanjaro's SpeQtrum platform. This module supports secure login and a unified interface for both digital circuits and analog evolutions:
 
 ```python
-from qilisdk.speqtrum import SpeQtrum
+from qilisdk.backends import CudaBackend, CudaSamplingMethod
+from qilisdk.digital import Circuit, H, M
 from qilisdk.functionals import Sampling
+from qilisdk.speqtrum import SpeQtrum
+
+
+# Build a single-qubit circuit
+circuit = Circuit(nqubits=1)
+circuit.add(H(0))
+circuit.add(M(0))
 
 # Login to QaaSBackend with credentials (or use environment variables)
 # This only needs to be run once.
-SpeQtrum.login(username="your_username", apikey="your_apikey")
+SpeQtrum.login(username="YOUR_USERNAME", apikey="YOUR_APIKEY")
 
 # Instantiate QaaSBackend
 client = SpeQtrum()
 
-# # Execute a pre-built circuit (see Digital Quantum Circuits section)
-job_id = client.submit(Sampling(circuit, 1000), device="cuda_state_vector")
+# Execute a pre-built circuit (see Digital Quantum Circuits section)
+# make sure to select the device (you can list available devices using ``client.list_devices()``)
+job_id = client.submit(Sampling(circuit, 1000), device="SELECTED_DEVICE")
 print("job id:", job_id)
 print("job status:", client.get_job(job_id).status)
 print("job result:", client.get_job(job_id).result)
@@ -241,18 +255,17 @@ print("CUDA Backend Results:", results)
 
 ### Time Evolution using Qutip
 
-For analog simulations, the new `TimeEvolution` and `Schedule` classes allow you to simulate time-dependent quantum dynamics. The following example uses a linear schedule to interpolate between two Hamiltonians on a Qutip backend:
+For analog simulations, the `TimeEvolution` and unified `Schedule` classes allow you to simulate time-dependent quantum dynamics. The following example uses callable coefficients defined over an interval to interpolate between two Hamiltonians on a Qutip backend:
 
 ```python
-import numpy as np
 from qilisdk.analog import Schedule, X, Z, Y
 from qilisdk.core import ket, tensor_prod
 from qilisdk.backends import QutipBackend
 from qilisdk.functionals import TimeEvolution
 
 # Define total time and timestep
-T = 100
-steps = np.linspace(0, T, T)
+T = 100.0
+dt = 0.1
 nqubits = 1
 
 # Define Hamiltonians
@@ -260,13 +273,14 @@ Hx = sum(X(i) for i in range(nqubits))
 Hz = sum(Z(i) for i in range(nqubits))
 
 # Build a time‑dependent schedule
-schedule = Schedule(T)
-
-# Add hx with a time‐dependent coefficient function
-schedule.add_hamiltonian(label="hx", hamiltonian=Hx, schedule=lambda t: 1 - steps[t] / T)
-
-# Add hz similarly
-schedule.add_hamiltonian(label="hz", hamiltonian=Hz, schedule=lambda t: steps[t] / T)
+schedule = Schedule(
+    hamiltonians={"hx": Hx, "hz": Hz},
+    coefficients={
+        "hx": {(0.0, T): lambda t: 1 - t / T},
+        "hz": {(0.0, T): lambda t: t / T},
+    },
+    dt=dt,
+)
 
 # draw the schedule
 schedule.draw()
@@ -418,6 +432,42 @@ print("Reconstructed Circuit:")
 restored_circuit.draw()
 ```
 
+### OpenFermion Integration
+
+`QiliSDK` can translate ``QubitOperator`` objects from ``OpenFermion`` to ``QiliSDK``'s ``Hamiltonian`` Objects and vice versa.
+
+This code is available under an optional dependency that can be installed using ``pip install qilisdk[openfermion]``.
+
+here is an example of the usage: 
+```python
+from openfermion.hamiltonians import jellium_model
+from openfermion.transforms import fourier_transform, jordan_wigner
+from openfermion.utils import Grid
+
+from qilisdk.utils.openfermion import openfermion_to_qilisdk, qilisdk_to_openfermion
+
+# Let's look at a very small model of jellium in 1D.
+grid = Grid(dimensions=1, length=3, scale=1.0)
+spinless = True
+
+# Get the momentum Hamiltonian.
+momentum_hamiltonian = jellium_model(grid, spinless)
+momentum_qubit_operator = jordan_wigner(momentum_hamiltonian)
+momentum_qubit_operator.compress()
+
+# Fourier transform the Hamiltonian to the position basis.
+position_hamiltonian = fourier_transform(momentum_hamiltonian, grid, spinless)
+position_qubit_operator = jordan_wigner(position_hamiltonian)
+position_qubit_operator.compress()
+
+qilisdk_ham = openfermion_to_qilisdk(position_qubit_operator)
+openfermion_ham = qilisdk_to_openfermion(qilisdk_ham)
+
+```
+
+
+
+
 ---
 
 ## Development

{qilisdk-0.1.6 → qilisdk-0.1.7}/README.md

@@ -3,6 +3,7 @@
 [![Python Versions](https://img.shields.io/pypi/pyversions/qilisdk.svg)](https://pypi.org/project/qilisdk/)
 [![PyPI Version](https://img.shields.io/pypi/v/qilisdk.svg)](https://pypi.org/project/qilisdk/)
 [![License](https://img.shields.io/pypi/l/qilisdk.svg)](#license)
+[![Docs](https://img.shields.io/badge/docs-latest-pink.svg)](https://qilimanjaro-tech.github.io/qilisdk/main/index.html)
 
 **QiliSDK** is a Python framework for writing digital and analog quantum algorithms and executing them across multiple quantum backends. Its modular design streamlines the development process and enables easy integration with a variety of quantum platforms.
 
@@ -157,18 +158,27 @@ print("Optimal Parameters:", result.optimal_parameters)
 QiliSDK includes a client for interacting with Qilimanjaro's SpeQtrum platform. This module supports secure login and a unified interface for both digital circuits and analog evolutions:
 
 ```python
-from qilisdk.speqtrum import SpeQtrum
+from qilisdk.backends import CudaBackend, CudaSamplingMethod
+from qilisdk.digital import Circuit, H, M
 from qilisdk.functionals import Sampling
+from qilisdk.speqtrum import SpeQtrum
+
+
+# Build a single-qubit circuit
+circuit = Circuit(nqubits=1)
+circuit.add(H(0))
+circuit.add(M(0))
 
 # Login to QaaSBackend with credentials (or use environment variables)
 # This only needs to be run once.
-SpeQtrum.login(username="your_username", apikey="your_apikey")
+SpeQtrum.login(username="YOUR_USERNAME", apikey="YOUR_APIKEY")
 
 # Instantiate QaaSBackend
 client = SpeQtrum()
 
-# # Execute a pre-built circuit (see Digital Quantum Circuits section)
-job_id = client.submit(Sampling(circuit, 1000), device="cuda_state_vector")
+# Execute a pre-built circuit (see Digital Quantum Circuits section)
+# make sure to select the device (you can list available devices using ``client.list_devices()``)
+job_id = client.submit(Sampling(circuit, 1000), device="SELECTED_DEVICE")
 print("job id:", job_id)
 print("job status:", client.get_job(job_id).status)
 print("job result:", client.get_job(job_id).result)
@@ -196,18 +206,17 @@ print("CUDA Backend Results:", results)
 
 ### Time Evolution using Qutip
 
-For analog simulations, the new `TimeEvolution` and `Schedule` classes allow you to simulate time-dependent quantum dynamics. The following example uses a linear schedule to interpolate between two Hamiltonians on a Qutip backend:
+For analog simulations, the `TimeEvolution` and unified `Schedule` classes allow you to simulate time-dependent quantum dynamics. The following example uses callable coefficients defined over an interval to interpolate between two Hamiltonians on a Qutip backend:
 
 ```python
-import numpy as np
 from qilisdk.analog import Schedule, X, Z, Y
 from qilisdk.core import ket, tensor_prod
 from qilisdk.backends import QutipBackend
 from qilisdk.functionals import TimeEvolution
 
 # Define total time and timestep
-T = 100
-steps = np.linspace(0, T, T)
+T = 100.0
+dt = 0.1
 nqubits = 1
 
 # Define Hamiltonians
@@ -215,13 +224,14 @@ Hx = sum(X(i) for i in range(nqubits))
 Hz = sum(Z(i) for i in range(nqubits))
 
 # Build a time‑dependent schedule
-schedule = Schedule(T)
-
-# Add hx with a time‐dependent coefficient function
-schedule.add_hamiltonian(label="hx", hamiltonian=Hx, schedule=lambda t: 1 - steps[t] / T)
-
-# Add hz similarly
-schedule.add_hamiltonian(label="hz", hamiltonian=Hz, schedule=lambda t: steps[t] / T)
+schedule = Schedule(
+    hamiltonians={"hx": Hx, "hz": Hz},
+    coefficients={
+        "hx": {(0.0, T): lambda t: 1 - t / T},
+        "hz": {(0.0, T): lambda t: t / T},
+    },
+    dt=dt,
+)
 
 # draw the schedule
 schedule.draw()
@@ -373,6 +383,42 @@ print("Reconstructed Circuit:")
 restored_circuit.draw()
 ```
 
+### OpenFermion Integration
+
+`QiliSDK` can translate ``QubitOperator`` objects from ``OpenFermion`` to ``QiliSDK``'s ``Hamiltonian`` Objects and vice versa.
+
+This code is available under an optional dependency that can be installed using ``pip install qilisdk[openfermion]``.
+
+here is an example of the usage: 
+```python
+from openfermion.hamiltonians import jellium_model
+from openfermion.transforms import fourier_transform, jordan_wigner
+from openfermion.utils import Grid
+
+from qilisdk.utils.openfermion import openfermion_to_qilisdk, qilisdk_to_openfermion
+
+# Let's look at a very small model of jellium in 1D.
+grid = Grid(dimensions=1, length=3, scale=1.0)
+spinless = True
+
+# Get the momentum Hamiltonian.
+momentum_hamiltonian = jellium_model(grid, spinless)
+momentum_qubit_operator = jordan_wigner(momentum_hamiltonian)
+momentum_qubit_operator.compress()
+
+# Fourier transform the Hamiltonian to the position basis.
+position_hamiltonian = fourier_transform(momentum_hamiltonian, grid, spinless)
+position_qubit_operator = jordan_wigner(position_hamiltonian)
+position_qubit_operator.compress()
+
+qilisdk_ham = openfermion_to_qilisdk(position_qubit_operator)
+openfermion_ham = qilisdk_to_openfermion(qilisdk_ham)
+
+```
+
+
+
+
 ---
 
 ## Development

{qilisdk-0.1.6 → qilisdk-0.1.7}/pyproject.toml

@@ -1,14 +1,14 @@
 [project]
 name = "qilisdk"
-version = "0.1.6"
+version = "0.1.7"
 description = "QiliSDK is a Python framework for writing digital and analog quantum algorithms and executing them across multiple quantum backends. Its modular design streamlines the development process and enables easy integration with a variety of quantum platforms."
 readme = "README.md"
 authors = [{name = "Qilimanjaro Quantum Tech", email = "info@qilimanjaro.tech"}]
-requires-python = ">=3.10"
+requires-python = ">=3.11"
 keywords = ["qilimanjaro", "quantum computing", "digital quantum computing", "analog quantum computing"]
 urls = { "Homepage" = "https://github.com/qilimanjaro-tech/qilisdk", "Documentation" = "https://qilimanjaro-tech.github.io/qilisdk/", "Source" = "https://github.com/qilimanjaro-tech/qilisdk", "Issues" = "https://github.com/qilimanjaro-tech/qilisdk/issues", "Changelog" = "https://github.com/qilimanjaro-tech/qilisdk/blob/main/CHANGELOG.md" }
 classifiers = [
-    "Development Status :: 3 - Alpha",
+    "Development Status :: 4 - Beta",
     "Environment :: Console",
     "Operating System :: POSIX :: Linux",
     "License :: OSI Approved :: Apache Software License",
@@ -18,49 +18,55 @@ classifiers = [
     "Intended Audience :: Developers",
     "Intended Audience :: Science/Research",
     "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
 ]
 dependencies = [
     "dill>=0.3.9",
-    "numpy>=1.26.4",
+    "numpy>=2.2.0",
     "ruamel-yaml>=0.18.16",
-    "scipy>=1.15.3",
+    "scipy>=1.16.3; sys_platform == 'darwin'",
+    "scipy>=1.15,<1.16.3; sys_platform != 'darwin'",
     "pydantic>=2.12.3",
     "pydantic-settings>=2.11.0",
     "loguru>=0.7.3",
     "matplotlib>=3.10.7",
+    "mkl-service>=2.4.2; sys_platform != 'darwin'",
 ]
 
 [project.optional-dependencies]
 cuda = [
-    "cuda-quantum-cu12==0.12.0.post1",
+    "cuda-quantum-cu12==0.13.0",
 ]
 speqtrum = [
-    "httpx>=0.28.1",
+    "httpx==0.28.1",
     "keyring>=25.6.0",
     "keyrings-alt>=5.0.2",
 ]
 qutip = [
-    "qutip>=5.2.1",
+    "qutip>=5.2.2",
     "qutip-qip>=0.4.1",
 ]
+openfermion = [
+    "openfermion>=1.7.1",
+]
 
 [dependency-groups]
 dev = [
-    "hypothesis>=6.142.3",
-    "ipykernel>=7.0.1",
+    "hypothesis>=6.147.0",
+    "ipykernel>=7.1.0",
     "mypy>=1.18.2",
     "pre-commit>=4.3.0",
     "pytest>=8.4.2",
     "pytest-sugar>=1.1.1",
-    "ruff>=0.14.2",
+    "ruff>=0.14.6",
     "towncrier>=25.8.0",
     "loguru-caplog>=0.2.0",
     "pytest-cov>=7.0.0",
 ]
 docs = [
+    "astroid<3.2",
     "nbsphinx>=0.9.7",
     "pypandoc>=1.15",
     "sphinx>=8.1.3",
@@ -72,6 +78,17 @@ docs = [
     "sphinxawesome-theme>=5.3.2",
 ]
 
+[tool.uv.sources]
+sphinx-multiversion = { git = "https://github.com/sphinx-contrib/multiversion", branch = "main"}
+numpy = [{ index = "numpy-mkl", marker = "sys_platform != 'darwin'" }]
+scipy = [{ index = "numpy-mkl", marker = "sys_platform != 'darwin'" }]
+mkl-service = [{ index = "numpy-mkl", marker = "sys_platform != 'darwin'" }]
+
+[[tool.uv.index]]
+name = "numpy-mkl"
+url = "https://urob.github.io/numpy-mkl"
+explicit = true
+
 [build-system]
 requires = ["hatchling"]
 build-backend = "hatchling.build"
@@ -94,10 +111,6 @@ exclude = [
 [tool.hatch.build.targets.wheel]
 packages = ["src/qilisdk"]
 
-[tool.uv.sources]
-cudaq = { git = "https://github.com/NVIDIA/cuda-quantum", tag = "0.11.0"}
-sphinx-multiversion = { git = "https://github.com/sphinx-contrib/multiversion", branch = "main"}
-
 [tool.ruff]
 line-length = 120
 output-format = "concise"
@@ -193,7 +206,7 @@ docstring-code-format = true
 docstring-code-line-length = "dynamic"
 
 [tool.mypy]
-python_version = "3.10"
+python_version = "3.13"
 ignore_missing_imports = true
 exclude = ["\\.ipynb$"]
 

{qilisdk-0.1.6 → qilisdk-0.1.7}/src/qilisdk/analog/__init__.py

@@ -13,7 +13,6 @@
 # limitations under the License.
 
 from .hamiltonian import Hamiltonian, I, PauliI, PauliX, PauliY, PauliZ, X, Y, Z
-from .linear_schedule import LinearSchedule
 from .schedule import Schedule
 
-__all__ = ["Hamiltonian", "I", "LinearSchedule", "PauliI", "PauliX", "PauliY", "PauliZ", "Schedule", "X", "Y", "Z"]
+__all__ = ["Hamiltonian", "I", "PauliI", "PauliX", "PauliY", "PauliZ", "Schedule", "X", "Y", "Z"]

{qilisdk-0.1.6 → qilisdk-0.1.7}/src/qilisdk/analog/hamiltonian.py

@@ -256,6 +256,7 @@ class Hamiltonian(Parameterizable):
         Raises:
             ValueError: If the provided coefficients include generic variables instead of parameters.
         """
+        super(Hamiltonian, self).__init__()
         self._elements: dict[tuple[PauliOperator, ...], complex | Term | Parameter] = defaultdict(complex)
         self._parameters: dict[str, Parameter] = {}
         if elements:
@@ -294,79 +295,11 @@ class Hamiltonian(Parameterizable):
             for k, v in self._elements.items()
         }
 
-    @property
-    def nparameters(self) -> int:
-        """Return the number of unique symbolic parameters contained in the Hamiltonian."""
-        return len(self._parameters)
-
     @property
     def parameters(self) -> dict[str, Parameter]:
         """Return a mapping from parameter labels to their corresponding parameter objects."""
         return self._parameters
 
-    def get_parameter_values(self) -> list[float]:
-        """Return the current numeric values of the Hamiltonian parameters."""
-        return [param.value for param in self._parameters.values()]
-
-    def get_parameter_names(self) -> list[str]:
-        """Return the ordered list of parameter labels defined in the Hamiltonian."""
-        return list(self._parameters.keys())
-
-    def get_parameters(self) -> dict[str, float]:
-        """Return a mapping from parameter labels to their current numerical values."""
-        return {label: param.value for label, param in self._parameters.items()}
-
-    def set_parameter_values(self, values: list[float]) -> None:
-        """
-        Update the numerical values of the Hamiltonian parameters.
-
-        Args:
-            values (list[float]): New values ordered according to ``get_parameter_names()``.
-
-        Raises:
-            ValueError: If the number of provided values does not match ``nparameters``.
-        """
-        if len(values) != self.nparameters:
-            raise ValueError(f"Provided {len(values)} but Hamiltonian has {self.nparameters} parameters.")
-        for i, parameter in enumerate(self._parameters.values()):
-            parameter.set_value(values[i])
-
-    def set_parameters(self, parameter_dict: dict[str, float]) -> None:
-        """
-        Update a subset of parameters by label.
-
-        Args:
-            parameter_dict (dict[str, float]): Mapping from parameter labels to new numerical values.
-
-        Raises:
-            ValueError: If an unknown parameter label is provided.
-        """
-        for label, param in parameter_dict.items():
-            if label not in self._parameters:
-                raise ValueError(f"Parameter {label} is not defined in this hamiltonian.")
-            self._parameters[label].set_value(param)
-
-    def get_parameter_bounds(self) -> dict[str, tuple[float, float]]:
-        """Return the lower and upper bounds currently associated with each parameter."""
-        return {k: v.bounds for k, v in self._parameters.items()}
-
-    def set_parameter_bounds(self, ranges: dict[str, tuple[float, float]]) -> None:
-        """
-        Update parameter bounds.
-
-        Args:
-            ranges (dict[str, tuple[float, float]]): Mapping from parameter labels to ``(lower, upper)`` bounds.
-
-        Raises:
-            ValueError: If an unknown parameter label is provided.
-        """
-        for label, bound in ranges.items():
-            if label not in self._parameters:
-                raise ValueError(
-                    f"The provided parameter label {label} is not defined in the list of parameters in this object."
-                )
-            self._parameters[label].set_bounds(bound[0], bound[1])
-
     def simplify(self) -> Hamiltonian:
         """Simplify the Hamiltonian expression by removing near-zero terms and accumulating constant terms.