microquantum 0.1.2__tar.gz → 0.4.0__tar.gz

{microquantum-0.1.2 → microquantum-0.4.0}/LICENSE

@@ -1,31 +1,21 @@
-MIT License
-
-Copyright (c) 2026 Ajit Kumar
-
-(Standard MIT License terms apply here)
-
-### `LICENSE`
-An open-source license is highly recommended. You can use the standard MIT License:
-
-```text
-MIT License
-
-Copyright (c) 2026 Your Name
-
-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
+MIT License
+
+Copyright (c) 2026 Ajit Kumar
+
+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.

microquantum-0.4.0/PKG-INFO

@@ -0,0 +1,265 @@
+Metadata-Version: 2.4
+Name: microquantum
+Version: 0.4.0
+Summary: A lightweight, NumPy-only quantum computing SDK foundation: circuits, problems, algorithms, a pluggable execution runtime, backends, experiments and analysis.
+Author: Ajit Kumar
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/ajit-ai/microquantum
+Project-URL: Repository, https://github.com/ajit-ai/microquantum
+Project-URL: Documentation, https://ajit-ai.github.io/microquantum/
+Project-URL: Issues, https://github.com/ajit-ai/microquantum/issues
+Project-URL: Changelog, https://github.com/ajit-ai/microquantum/blob/main/CHANGELOG.md
+Keywords: quantum,quantum-computing,quantum-circuit,simulator,qiskit-alternative,vqe,qaoa,grover,shor,qml,qec,qubo,optimization,sdk
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+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 :: Chemistry
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Topic :: Scientific/Engineering :: Physics
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.20.0
+Provides-Extra: docs
+Requires-Dist: sphinx>=8.1.3; extra == "docs"
+Requires-Dist: sphinx-autoapi>=3.8.0; extra == "docs"
+Requires-Dist: furo>=2024.8.6; extra == "docs"
+Provides-Extra: gpu
+Requires-Dist: cupy-cuda12x>=12.0; extra == "gpu"
+Provides-Extra: all
+Requires-Dist: cupy-cuda12x>=12.0; extra == "all"
+Requires-Dist: sphinx>=8.1.3; extra == "all"
+Requires-Dist: sphinx-autoapi>=3.8.0; extra == "all"
+Requires-Dist: furo>=2024.8.6; extra == "all"
+Dynamic: license-file
+
+# Microquantum
+
+**A lightweight, NumPy-only quantum computing SDK — MIT licensed and dependency-light.**
+
+[![CI](https://img.shields.io/github/actions/workflow/status/ajit-ai/microquantum/ci.yml?branch=main&label=CI)](https://github.com/ajit-ai/microquantum/actions)
+[![Docs](https://img.shields.io/badge/docs-GitHub%20Pages-blue)](https://ajit-ai.github.io/microquantum/)
+[![PyPI - Version](https://img.shields.io/pypi/v/microquantum)](https://pypi.org/project/microquantum/)
+[![PyPI - Python Versions](https://img.shields.io/pypi/pyversions/microquantum)](https://pypi.org/project/microquantum/)
+[![PyPI - Downloads](https://img.shields.io/pypi/dm/microquantum)](https://pypi.org/project/microquantum/)
+[![License: MIT](https://img.shields.io/github/license/ajit-ai/microquantum)](LICENSE)
+
+microquantum is an **independent quantum computing SDK**. It is **not** a port or
+wrapper around Qiskit, Cirq, or OpenQASM — every circuit, operator, simulator and
+algorithm is implemented from scratch with NumPy as the only hard dependency.
+
+
+> **Positioning**: an *SDK* — a complete kit for building quantum applications.
+> The core engine and algorithms form a *library* (you call it); the
+> `DomainAdapter` pipeline and backend/provider abstractions form an embedded
+> *framework* (it calls your code); a standardized result contract ties it all
+> together for downstream solvers.
+
+---
+
+## What's Included
+
+| System | Description |
+|---|---|
+| **Core engine** | `QuantumCircuit`, operators, Pauli algebra, `StateVector` / `DensityMatrix`, measurement, gradients, registers, serialization, transpiler + `PassManager` |
+| **Algorithms** | VQE, ADAPT-VQE, VQD, QAOA, Grover, Shor, QFT, phase/amplitude estimation, HHL, Hamiltonian simulation (+ qDRIFT, 4th-order Trotter), quantum walks, BV, DJ |
+| **Backends** | Statevector, noisy DensityMatrix, MPS and tree tensor networks, pluggable NumPy/CuPy array backend, high-level `Executor`, async `Job` |
+| **Execution results & analytics** | structured `ExecutionRecord`s, `ParameterSweep`, `Experiment` / `ExperimentResult`, sampling / expectation / state analysis and `ResultAggregator` (MQ-07) |
+| **Providers** | Raw REST clients for IBM Quantum and IonQ (no Qiskit/Cirq/OpenQASM), `CircuitSerializer`, `HardwareBackend` adapter |
+| **QML / QEC** | Encodings, quantum kernels, variational classifier; repetition/Shor/bit-flip/phase-flip codes |
+| **Chemistry** | H₂/LiH Hamiltonians, UCCSD and hardware-efficient ansätze |
+| **Optimization** | QUBO/Ising toolchain: `QUBOBuilder`, `IsingConverter`, constraint penalties |
+| **Benchmarks** | Quantum volume, randomized benchmarking, XEB, CLOPS, GST, cycle benchmarking, layer fidelity |
+| **Mitigation** | Zero-noise extrapolation (ZNE), probabilistic error cancellation (PEC), measurement-error mitigation (MEM) |
+| **Result contract** | `microquantum.analytics.result.Result` — a standardized, JSON-safe decision schema |
+| **Domain framework** | `DomainAdapter` ABC: validate → encode → execute → decode, with `QuantumProblem` / `QuantumResult` / `ResultCache` |
+
+---
+---
+
+## Installation
+
+Requires **Python 3.10, 3.11, 3.12, or 3.13** and NumPy ≥ 1.20 (installed automatically).
+
+```bash
+pip install microquantum
+```
+
+Or with [uv](https://docs.astral.sh/uv/):
+
+```bash
+uv pip install microquantum
+```
+
+Or from source:
+
+```bash
+git clone https://github.com/ajit-ai/microquantum.git
+cd microquantum
+uv sync --group dev
+```
+
+Documentation for the Developer Preview is published at
+<https://ajit-ai.github.io/microquantum/> (auto-deployed from the `main`
+branch); the Sphinx sources live in `docs/`.
+
+Optional GPU acceleration (NumPy stays the default; the CuPy backend is opt-in):
+
+```bash
+pip install "microquantum[gpu]"
+```
+
+Verify:
+
+```bash
+python -c "import microquantum; print(microquantum.__version__)"
+```
+
+---
+
+## Quick Start
+
+### 1. Bell state in two minutes
+
+```python
+from microquantum import Executor, QuantumCircuit, StatevectorBackend
+
+qc = QuantumCircuit(2)
+qc.h(0)        # Hadamard on qubit 0
+qc.cx(0, 1)    # CNOT (control=0, target=1)
+
+result = Executor(backend=StatevectorBackend()).run(qc, shots=1024)
+print(result.counts)          # {'00': ~512, '11': ~512}
+print(result.most_frequent()) # '00' or '11'
+```
+
+`Executor` is the single high-level entry point: pass any `Backend` (statevector,
+noisy density matrix, MPS, tensor network, or a hardware provider) — or a
+`NoiseModel` for built-in noisy simulation. Every `Backend` also exposes a direct
+high-level `backend.run(circuit, shots=1024, seed=None)` call.
+
+### 2. The standardized result contract
+
+```python
+from microquantum.analytics.result import Result
+
+result = Result(
+    problem="optimization",
+    solution={"route": "A->C->B", "cost": 42.0},
+    confidence=0.91,
+    qubit_count=8,
+    runtime_ms=48.3,
+    baseline={"route": "A->B->C", "cost": 51.7},
+)
+print(result.to_json())
+print(result.improved_over_baseline)  # True
+```
+
+### 3. Running on real hardware
+
+```python
+from microquantum import Executor, HardwareBackend, IBMQuantumCredentials, IBMQuantumProvider
+
+provider = IBMQuantumProvider(IBMQuantumCredentials(api_token="..."))
+backend = HardwareBackend(provider)
+
+result = Executor(backend=backend).run(qc, shots=1024)
+```
+
+---
+
+## Architecture Principles
+
+1. **Independent implementation** — all quantum operations are implemented from
+   scratch using NumPy. No dependence on Qiskit, Cirq, OpenQASM, Strawberry
+   Fields, or any other quantum SDK.
+2. **Layer separation** — each layer only depends on layers below it:
+   Analytics never touches raw matrices; domain adapters never bypass the core engine.
+
+   ```
+   Engine  →  Algorithms  →  Backends  →  Providers  →  NumPy
+   ```
+
+3. **Big-endian qubit ordering** — qubit 0 is the most significant bit; tensor
+   axis 0 = qubit 0. This matches the mathematical convention.
+4. **Standardized results** — every successful run funnels into a typed result
+   (`BackendResult`, `ExecutorResult`, `*Result`, `Result`) that can be
+   serialized with `to_dict()` / `to_json()`.
+5. **Test-driven** — a full test suite ships with the SDK and runs in CI.
+
+---
+
+## Project Structure
+
+```
+microquantum/
+├── src/microquantum/
+│   ├── core/          # Quantum engine, circuits, operators, transpiler
+│   ├── algorithms/    # 23+ quantum algorithms
+│   ├── experiments/   # Execution records, sweeps, experiments (MQ-07)
+│   ├── analysis/      # Sampling / expectation / state analysis (MQ-07)
+│   ├── backends/      # Simulators, noise, tensor networks, Executor
+│   ├── providers/     # IBM Quantum & IonQ hardware clients (REST)
+│   ├── analytics/     # CSV loading, result contract, analytics base
+│   ├── optimization/  # QUBO / Ising toolchain
+│   ├── qml/           # Quantum machine learning
+│   ├── qec/           # Error correction codes
+│   ├── benchmarks/    # Quantum benchmarking suite
+│   ├── chemistry/     # Molecular Hamiltonians and ansätze
+│   ├── mitigation/    # Error mitigation (ZNE, PEC, MEM)
+│   └── optimizers/    # Classical optimizers
+├── examples/          # Runnable demo scripts
+├── docs/              # Sphinx documentation
+└── pyproject.toml     # Package configuration
+```
+
+---
+
+## Development
+
+```bash
+# Install dev tooling (pytest, coverage, mypy, ruff, sphinx)
+uv sync --group dev
+
+# Run the test suite (with coverage report)
+uv run pytest tests/
+
+# Type check (0 errors expected)
+uv run mypy src/microquantum/ --ignore-missing-imports
+
+# Lint / format
+uv run ruff check src tests examples
+
+# Build the docs
+uv run sphinx-build docs docs/_build/html
+```
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for the contribution workflow and
+[CHANGELOG.md](CHANGELOG.md) for release history.
+
+---
+
+## Roadmap
+
+- **v0.4.0** (current) — Developer Preview (see `docs/releases/developer-preview.rst`):
+  complete warning-free documentation with auto-generated API reference,
+  GitHub Pages deployment, and a consolidated CI/packaging pipeline.
+- **v0.3.0** — public open-source release: unified `Backend.run()`,
+  serializable results (`to_dict()`), SPDX/legacy metadata cleanup, coverage +
+  ruff gates, SDK-only docs.
+- **Next** — automated PyPI release workflow on version tags, stricter mypy
+  coverage, more hardware providers and tutorials.
+
+---
+
+## License
+
+MIT — see [LICENSE](LICENSE). Built as an independent, dependency-light quantum
+computing SDK: use it, fork it, build on it.

microquantum-0.4.0/README.md

@@ -0,0 +1,223 @@
+# Microquantum
+
+**A lightweight, NumPy-only quantum computing SDK — MIT licensed and dependency-light.**
+
+[![CI](https://img.shields.io/github/actions/workflow/status/ajit-ai/microquantum/ci.yml?branch=main&label=CI)](https://github.com/ajit-ai/microquantum/actions)
+[![Docs](https://img.shields.io/badge/docs-GitHub%20Pages-blue)](https://ajit-ai.github.io/microquantum/)
+[![PyPI - Version](https://img.shields.io/pypi/v/microquantum)](https://pypi.org/project/microquantum/)
+[![PyPI - Python Versions](https://img.shields.io/pypi/pyversions/microquantum)](https://pypi.org/project/microquantum/)
+[![PyPI - Downloads](https://img.shields.io/pypi/dm/microquantum)](https://pypi.org/project/microquantum/)
+[![License: MIT](https://img.shields.io/github/license/ajit-ai/microquantum)](LICENSE)
+
+microquantum is an **independent quantum computing SDK**. It is **not** a port or
+wrapper around Qiskit, Cirq, or OpenQASM — every circuit, operator, simulator and
+algorithm is implemented from scratch with NumPy as the only hard dependency.
+
+
+> **Positioning**: an *SDK* — a complete kit for building quantum applications.
+> The core engine and algorithms form a *library* (you call it); the
+> `DomainAdapter` pipeline and backend/provider abstractions form an embedded
+> *framework* (it calls your code); a standardized result contract ties it all
+> together for downstream solvers.
+
+---
+
+## What's Included
+
+| System | Description |
+|---|---|
+| **Core engine** | `QuantumCircuit`, operators, Pauli algebra, `StateVector` / `DensityMatrix`, measurement, gradients, registers, serialization, transpiler + `PassManager` |
+| **Algorithms** | VQE, ADAPT-VQE, VQD, QAOA, Grover, Shor, QFT, phase/amplitude estimation, HHL, Hamiltonian simulation (+ qDRIFT, 4th-order Trotter), quantum walks, BV, DJ |
+| **Backends** | Statevector, noisy DensityMatrix, MPS and tree tensor networks, pluggable NumPy/CuPy array backend, high-level `Executor`, async `Job` |
+| **Execution results & analytics** | structured `ExecutionRecord`s, `ParameterSweep`, `Experiment` / `ExperimentResult`, sampling / expectation / state analysis and `ResultAggregator` (MQ-07) |
+| **Providers** | Raw REST clients for IBM Quantum and IonQ (no Qiskit/Cirq/OpenQASM), `CircuitSerializer`, `HardwareBackend` adapter |
+| **QML / QEC** | Encodings, quantum kernels, variational classifier; repetition/Shor/bit-flip/phase-flip codes |
+| **Chemistry** | H₂/LiH Hamiltonians, UCCSD and hardware-efficient ansätze |
+| **Optimization** | QUBO/Ising toolchain: `QUBOBuilder`, `IsingConverter`, constraint penalties |
+| **Benchmarks** | Quantum volume, randomized benchmarking, XEB, CLOPS, GST, cycle benchmarking, layer fidelity |
+| **Mitigation** | Zero-noise extrapolation (ZNE), probabilistic error cancellation (PEC), measurement-error mitigation (MEM) |
+| **Result contract** | `microquantum.analytics.result.Result` — a standardized, JSON-safe decision schema |
+| **Domain framework** | `DomainAdapter` ABC: validate → encode → execute → decode, with `QuantumProblem` / `QuantumResult` / `ResultCache` |
+
+---
+---
+
+## Installation
+
+Requires **Python 3.10, 3.11, 3.12, or 3.13** and NumPy ≥ 1.20 (installed automatically).
+
+```bash
+pip install microquantum
+```
+
+Or with [uv](https://docs.astral.sh/uv/):
+
+```bash
+uv pip install microquantum
+```
+
+Or from source:
+
+```bash
+git clone https://github.com/ajit-ai/microquantum.git
+cd microquantum
+uv sync --group dev
+```
+
+Documentation for the Developer Preview is published at
+<https://ajit-ai.github.io/microquantum/> (auto-deployed from the `main`
+branch); the Sphinx sources live in `docs/`.
+
+Optional GPU acceleration (NumPy stays the default; the CuPy backend is opt-in):
+
+```bash
+pip install "microquantum[gpu]"
+```
+
+Verify:
+
+```bash
+python -c "import microquantum; print(microquantum.__version__)"
+```
+
+---
+
+## Quick Start
+
+### 1. Bell state in two minutes
+
+```python
+from microquantum import Executor, QuantumCircuit, StatevectorBackend
+
+qc = QuantumCircuit(2)
+qc.h(0)        # Hadamard on qubit 0
+qc.cx(0, 1)    # CNOT (control=0, target=1)
+
+result = Executor(backend=StatevectorBackend()).run(qc, shots=1024)
+print(result.counts)          # {'00': ~512, '11': ~512}
+print(result.most_frequent()) # '00' or '11'
+```
+
+`Executor` is the single high-level entry point: pass any `Backend` (statevector,
+noisy density matrix, MPS, tensor network, or a hardware provider) — or a
+`NoiseModel` for built-in noisy simulation. Every `Backend` also exposes a direct
+high-level `backend.run(circuit, shots=1024, seed=None)` call.
+
+### 2. The standardized result contract
+
+```python
+from microquantum.analytics.result import Result
+
+result = Result(
+    problem="optimization",
+    solution={"route": "A->C->B", "cost": 42.0},
+    confidence=0.91,
+    qubit_count=8,
+    runtime_ms=48.3,
+    baseline={"route": "A->B->C", "cost": 51.7},
+)
+print(result.to_json())
+print(result.improved_over_baseline)  # True
+```
+
+### 3. Running on real hardware
+
+```python
+from microquantum import Executor, HardwareBackend, IBMQuantumCredentials, IBMQuantumProvider
+
+provider = IBMQuantumProvider(IBMQuantumCredentials(api_token="..."))
+backend = HardwareBackend(provider)
+
+result = Executor(backend=backend).run(qc, shots=1024)
+```
+
+---
+
+## Architecture Principles
+
+1. **Independent implementation** — all quantum operations are implemented from
+   scratch using NumPy. No dependence on Qiskit, Cirq, OpenQASM, Strawberry
+   Fields, or any other quantum SDK.
+2. **Layer separation** — each layer only depends on layers below it:
+   Analytics never touches raw matrices; domain adapters never bypass the core engine.
+
+   ```
+   Engine  →  Algorithms  →  Backends  →  Providers  →  NumPy
+   ```
+
+3. **Big-endian qubit ordering** — qubit 0 is the most significant bit; tensor
+   axis 0 = qubit 0. This matches the mathematical convention.
+4. **Standardized results** — every successful run funnels into a typed result
+   (`BackendResult`, `ExecutorResult`, `*Result`, `Result`) that can be
+   serialized with `to_dict()` / `to_json()`.
+5. **Test-driven** — a full test suite ships with the SDK and runs in CI.
+
+---
+
+## Project Structure
+
+```
+microquantum/
+├── src/microquantum/
+│   ├── core/          # Quantum engine, circuits, operators, transpiler
+│   ├── algorithms/    # 23+ quantum algorithms
+│   ├── experiments/   # Execution records, sweeps, experiments (MQ-07)
+│   ├── analysis/      # Sampling / expectation / state analysis (MQ-07)
+│   ├── backends/      # Simulators, noise, tensor networks, Executor
+│   ├── providers/     # IBM Quantum & IonQ hardware clients (REST)
+│   ├── analytics/     # CSV loading, result contract, analytics base
+│   ├── optimization/  # QUBO / Ising toolchain
+│   ├── qml/           # Quantum machine learning
+│   ├── qec/           # Error correction codes
+│   ├── benchmarks/    # Quantum benchmarking suite
+│   ├── chemistry/     # Molecular Hamiltonians and ansätze
+│   ├── mitigation/    # Error mitigation (ZNE, PEC, MEM)
+│   └── optimizers/    # Classical optimizers
+├── examples/          # Runnable demo scripts
+├── docs/              # Sphinx documentation
+└── pyproject.toml     # Package configuration
+```
+
+---
+
+## Development
+
+```bash
+# Install dev tooling (pytest, coverage, mypy, ruff, sphinx)
+uv sync --group dev
+
+# Run the test suite (with coverage report)
+uv run pytest tests/
+
+# Type check (0 errors expected)
+uv run mypy src/microquantum/ --ignore-missing-imports
+
+# Lint / format
+uv run ruff check src tests examples
+
+# Build the docs
+uv run sphinx-build docs docs/_build/html
+```
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for the contribution workflow and
+[CHANGELOG.md](CHANGELOG.md) for release history.
+
+---
+
+## Roadmap
+
+- **v0.4.0** (current) — Developer Preview (see `docs/releases/developer-preview.rst`):
+  complete warning-free documentation with auto-generated API reference,
+  GitHub Pages deployment, and a consolidated CI/packaging pipeline.
+- **v0.3.0** — public open-source release: unified `Backend.run()`,
+  serializable results (`to_dict()`), SPDX/legacy metadata cleanup, coverage +
+  ruff gates, SDK-only docs.
+- **Next** — automated PyPI release workflow on version tags, stricter mypy
+  coverage, more hardware providers and tutorials.
+
+---
+
+## License
+
+MIT — see [LICENSE](LICENSE). Built as an independent, dependency-light quantum
+computing SDK: use it, fork it, build on it.

microquantum-0.4.0/pyproject.toml

@@ -0,0 +1,134 @@
+[build-system]
+requires = ["setuptools>=61.0.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "microquantum"
+dynamic = ["version"]
+description = "A lightweight, NumPy-only quantum computing SDK foundation: circuits, problems, algorithms, a pluggable execution runtime, backends, experiments and analysis."
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.10"
+authors = [
+    {name = "Ajit Kumar"},
+]
+keywords = [
+    "quantum",
+    "quantum-computing",
+    "quantum-circuit",
+    "simulator",
+    "qiskit-alternative",
+    "vqe",
+    "qaoa",
+    "grover",
+    "shor",
+    "qml",
+    "qec",
+    "qubo",
+    "optimization",
+    "sdk",
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Science/Research",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Scientific/Engineering :: Chemistry",
+    "Topic :: Scientific/Engineering :: Mathematics",
+    "Topic :: Scientific/Engineering :: Physics",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+dependencies = [
+    "numpy>=1.20.0",
+]
+
+[project.optional-dependencies]
+docs = [
+    "sphinx>=8.1.3",
+    "sphinx-autoapi>=3.8.0",
+    "furo>=2024.8.6",
+]
+gpu = [
+    "cupy-cuda12x>=12.0",
+]
+all = [
+    "cupy-cuda12x>=12.0",
+    "sphinx>=8.1.3",
+    "sphinx-autoapi>=3.8.0",
+    "furo>=2024.8.6",
+]
+
+[project.urls]
+Homepage = "https://github.com/ajit-ai/microquantum"
+Repository = "https://github.com/ajit-ai/microquantum"
+Documentation = "https://ajit-ai.github.io/microquantum/"
+Issues = "https://github.com/ajit-ai/microquantum/issues"
+Changelog = "https://github.com/ajit-ai/microquantum/blob/main/CHANGELOG.md"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools]
+include-package-data = false
+
+[tool.setuptools.dynamic]
+version = {attr = "microquantum.__version__"}
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts = "--cov=microquantum --cov-report=term-missing"
+
+[tool.coverage.run]
+source = ["microquantum"]
+
+[tool.coverage.report]
+show_missing = true
+skip_covered = true
+exclude_lines = [
+    "pragma: no cover",
+    "if TYPE_CHECKING:",
+    "raise NotImplementedError",
+]
+
+[tool.mypy]
+python_version = "3.12"
+warn_return_any = true
+warn_unused_configs = true
+warn_redundant_casts = true
+check_untyped_defs = true
+disallow_incomplete_defs = true
+no_implicit_optional = true
+strict_equality = true
+ignore_missing_imports = true
+
+[[tool.mypy.overrides]]
+module = ["microquantum.core.circuit", "microquantum.core.gradient"]
+disable_error_code = ["assignment", "arg-type", "misc", "union-attr", "index"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py310"
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "B", "SIM"]
+ignore = ["E501"]
+
+[tool.ruff.format]
+quote-style = "double"
+indent-style = "space"
+
+[dependency-groups]
+dev = [
+    "pytest>=8.3.5",
+    "pytest-cov>=6.0",
+    "mypy>=1.0",
+    "ruff>=0.9",
+    "sphinx>=8.1.3",
+    "sphinx-autoapi>=3.8.0",
+    "furo>=2024.8.6",
+]

{microquantum-0.1.2 → microquantum-0.4.0}/setup.cfg

@@ -1,4 +1,4 @@
-[egg_info]
-tag_build = 
-tag_date = 0
-
+[egg_info]
+tag_build = 
+tag_date = 0
+