semvec/pypi-packages huggingface dataset:
stock-viewer 0.1.20
Simple stock viewer program.
Requires Python: >=3.8
Keywords: writing, translate

# stock-viewer

Simple stock viewer program.

![logo](https://raw.githubusercontent.com/trucomanx/StockViewer/main/screenshot.png)

## 1. Installing

To install the package from [PyPI](https://pypi.org/project/stock_viewer/), follow the instructions below:


```bash
pip install --upgrade stock_viewer
```

Execute `which stock-viewer` to see where it was installed, probably in `/home/USERNAME/.local/bin/stock-viewer`.

### Using

To start, use the command below:

```bash
stock-viewer
```

The program needs a *.stocks.json file in this format:

```
{
    "KLBN4.SA": {
        "average_price": 4.16,
        "quantity": 9,
        "category": [
            "Sales"
        ]
    },
    "ALUP4.SA": {
        "average_price": 9.42,
        "quantity": 8,
        "category": [
            "Finance"
        ]
    },
    "CPFE3.SA": {
        "average_price": 30.25,
        "quantity": 10,
        "category": [
            "Energy"
        ]
    }
}
```

## 2. More information

If you want more information go to [doc](https://github.com/trucomanx/StockViewer/blob/main/doc) directory.

## 3. Buy me a coffee

If you find this tool useful and would like to support its development, you can buy me a coffee!  
Your donations help keep the project running and improve future updates.  

[☕ Buy me a coffee](https://ko-fi.com/trucomanx) 

## 4. License

This project is licensed under the GPL license. See the `LICENSE` file for more details.
devqubit-ui 0.1.12
Web interface for devqubit experiment tracking
Requires Python: <3.14,>=3.11
Keywords: devqubit, experiment-tracking, fastapi, react, web-ui

# devqubit-ui

[![PyPI](https://img.shields.io/pypi/v/devqubit-ui)](https://pypi.org/project/devqubit-ui/)

Web UI for [devqubit](https://github.com/devqubit-labs/devqubit) — browse runs, view artifacts, compare experiments, and manage baselines in a local web interface.

> [!IMPORTANT]
> **This is an internal UI package.** Install via `pip install "devqubit[ui]"` and launch with `devqubit ui`.

## Installation

```bash
pip install "devqubit[ui]"
```

## Usage

### CLI

```bash
devqubit ui                           # http://127.0.0.1:8080
devqubit ui --port 9000               # custom port
devqubit ui --workspace /path/to/.devqubit  # custom workspace
```

### Python

```python
from devqubit.ui import run_server

run_server(port=8080)
```

### Production

```bash
uvicorn devqubit_ui.app:create_app --factory --host 0.0.0.0 --port 8080
```

## Features

- **Run browser** — list, filter, and search runs across projects
- **Run details** — parameters, metrics, tags, artifacts, and fingerprints
- **Artifact viewer** — inline JSON/text viewing; download for binary formats
- **Diff view** — side-by-side run comparison with TVD analysis
- **Projects & groups** — navigate by project, group, or sweep
- **Baseline management** — set, view, and clear project baselines
- **REST API** — JSON endpoints at `/api/*` for programmatic access

## Frontend Development

```bash
cd frontend
npm install
npm run dev       # dev server with HMR (proxies /api => :8000)
npm run build     # production build => auto-copied to src/devqubit_ui/static/
```

## License

Apache 2.0
devqubit-qiskit-runtime 0.1.12
devqubit adapter for IBM Qiskit Runtime
Requires Python: <3.14,>=3.11
Keywords: experiment-tracking, qiskit, qiskit-runtime, quantum

# devqubit-qiskit-runtime

[![PyPI](https://img.shields.io/pypi/v/devqubit-qiskit-runtime)](https://pypi.org/project/devqubit-qiskit-runtime/)

IBM Qiskit Runtime adapter for [devqubit](https://github.com/devqubit-labs/devqubit) — automatic circuit capture, transpilation management, calibration snapshots, and result logging for Runtime V2 primitives (`SamplerV2`, `EstimatorV2`).

> [!IMPORTANT]
> **This is an internal adapter package.** Install via `pip install "devqubit[qiskit-runtime]"` and use the `devqubit` public API.

## Installation

```bash
pip install "devqubit[qiskit-runtime]"
```

## Usage

```python
from qiskit import QuantumCircuit
from qiskit_ibm_runtime import QiskitRuntimeService, SamplerV2
from devqubit import track

qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
qc.measure_all()

service = QiskitRuntimeService()
backend = service.backend("ibm_brisbane")

with track(project="hardware-run") as run:
    sampler = run.wrap(SamplerV2(backend))
    job = sampler.run([(qc,)])
    result = job.result()
```

### Transpilation Modes

```python
# Auto (default): transpile to ISA only if needed
sampler = run.wrap(SamplerV2(backend))
job = sampler.run([qc], devqubit_transpilation_mode="auto")

# Manual: you handle transpilation yourself
job = sampler.run([isa_circuit], devqubit_transpilation_mode="manual")
```

## What's Captured

| Artifact | Kind | Role |
|---|---|---|
| QPY binary | `qiskit.qpy.circuits` | `program` |
| Transpiled QPY | `qiskit.qpy.circuits.transpiled` | `program` |
| OpenQASM 3 | `source.openqasm3` | `program` |
| PUB structure | `qiskit_runtime.pubs.json` | `program` |
| Sampler counts | `result.counts.json` | `result` |
| Estimator values | `result.qiskit_runtime.estimator.json` | `result` |
| Backend properties | `device.qiskit_runtime.raw_properties.json` | `device_raw` |
| Execution envelope | `devqubit.envelope.json` | `envelope` |

## Documentation

See the [Adapters guide](https://devqubit.readthedocs.io/en/latest/guides/adapters.html) for transpilation modes, performance tuning, and batch execution.

## License

Apache 2.0
devqubit-qiskit 0.1.12
devqubit adapter for Qiskit
Requires Python: <3.14,>=3.11
Keywords: experiment-tracking, qiskit, quantum

# devqubit-qiskit

[![PyPI](https://img.shields.io/pypi/v/devqubit-qiskit)](https://pypi.org/project/devqubit-qiskit/)

Qiskit adapter for [devqubit](https://github.com/devqubit-labs/devqubit) — automatic circuit capture, backend snapshots, and result logging for Qiskit and Aer backends.

> [!IMPORTANT]
> **This is an internal adapter package.** Install via `pip install "devqubit[qiskit]"` and use the `devqubit` public API.

## Installation

```bash
pip install "devqubit[qiskit]"
```

## Usage

```python
from qiskit import QuantumCircuit
from qiskit_aer import AerSimulator
from devqubit import track

qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
qc.measure_all()

with track(project="bell-state") as run:
    backend = run.wrap(AerSimulator())
    job = backend.run(qc, shots=1000)
    counts = job.result().get_counts()
```

## What's Captured

| Artifact | Kind | Role |
|---|---|---|
| QPY binary | `qiskit.qpy.circuits` | `program` |
| OpenQASM 3 | `source.openqasm3` | `program` |
| Circuit diagram | `qiskit.circuits.diagram` | `program` |
| Measurement counts | `result.counts.json` | `result` |
| Full SDK result | `result.qiskit.result_json` | `result_raw` |
| Backend properties | `device.qiskit.raw_properties.json` | `device_raw` |
| Execution envelope | `devqubit.envelope.json` | `envelope` |

## Documentation

See the [Adapters guide](https://devqubit.readthedocs.io/en/latest/guides/adapters.html) for details on wrapping options, batch execution, and performance tuning.

## License

Apache 2.0
devqubit-pennylane 0.1.12
devqubit adapter for Pennylane
Requires Python: <3.14,>=3.11
Keywords: experiment-tracking, pennylane, quantum

# devqubit-pennylane

[![PyPI](https://img.shields.io/pypi/v/devqubit-pennylane)](https://pypi.org/project/devqubit-pennylane/)

PennyLane adapter for [devqubit](https://github.com/devqubit-labs/devqubit) — automatic tape capture, device snapshots, and result logging for PennyLane devices and QNode workflows.

> [!IMPORTANT]
> **This is an internal adapter package.** Install via `pip install "devqubit[pennylane]"` and use the `devqubit` public API.

## Installation

```bash
pip install "devqubit[pennylane]"
```

## Usage

```python
import pennylane as qml
from devqubit import track

dev = qml.device("default.qubit", wires=2, shots=1000)

@qml.qnode(dev)
def circuit():
    qml.Hadamard(wires=0)
    qml.CNOT(wires=[0, 1])
    return qml.counts()

with track(project="pennylane-exp") as run:
    run.wrap(dev)       # in-place device patching
    counts = circuit()  # QNodes using this device are tracked automatically
```

### Multi-Layer Stack

PennyLane can act as a frontend to other execution providers. The adapter captures the full stack:

```python
# Braket backend through PennyLane
dev = qml.device("braket.aws.qubit", wires=2, device_arn="...")

# Qiskit backend through PennyLane
dev = qml.device("qiskit.remote", wires=2, backend="ibm_brisbane")
```

## What's Captured

| Artifact | Kind | Role |
|---|---|---|
| Tape JSON | `pennylane.tapes.json` | `program` |
| Tape diagram | `pennylane.tapes.txt` | `program` |
| Results | `result.pennylane.output.json` | `result` |
| Device properties | `device.pennylane.raw_properties.json` | `device_raw` |
| Execution envelope | `devqubit.envelope.json` | `envelope` |

## Documentation

See the [Adapters guide](https://devqubit.readthedocs.io/en/latest/guides/adapters.html) for performance tuning (`log_every_n`), parameter sweeps, and multi-layer stack details.

## License

Apache 2.0
devqubit-engine 0.1.12
Internal core runtime for devqubit
Requires Python: <3.14,>=3.11
Keywords: experiment-tracking, quantum

# devqubit-engine

Core engine for devqubit experiment tracking. Provides storage, registry, run management, comparison, and CLI.

> [!IMPORTANT]
> Users should install `devqubit` (the meta-package) instead, which includes this package plus convenient extras.

## Installation

```bash
pip install devqubit-engine
```

## What's Included

- **Run tracking** — `track()` context manager, parameter/metric/artifact logging
- **Storage** — Content-addressable object store with SHA-256 deduplication
- **Registry** — Run indexing, search, baselines, groups
- **Comparison** — `diff()`, `diff_runs()`, TVD analysis, calibration drift detection
- **Verification** — `verify()` for CI/CD baseline checks
- **Bundles** — Portable run export/import
- **CLI** — `devqubit list`, `show`, `diff`, `verify`, `pack`, `unpack`

## Usage

```python
from devqubit import track

with track(project="my-experiment") as run:
    run.log_param("shots", 1000)
    run.log_metric("fidelity", 0.95)
    run.log_json(name="counts", obj={"00": 502, "11": 498}, role="results")
```

## Adapters

Circuit capture requires SDK-specific adapters (separate packages):

```bash
pip install devqubit[qiskit]         # Qiskit + Aer
pip install devqubit[qiskit-runtime] # IBM Quantum Runtime
pip install devqubit[braket]         # Amazon Braket
pip install devqubit[cirq]           # Google Cirq
pip install devqubit[pennylane]      # PennyLane
```

## Configuration

```bash
export DEVQUBIT_HOME=~/.devqubit
export DEVQUBIT_CAPTURE_GIT=true
export DEVQUBIT_CAPTURE_PIP=true
```

## License

Apache 2.0
devqubit-cudaq 0.1.12
devqubit adapter for CUDA-Q
Requires Python: <3.14,>=3.11
Keywords: cudaq, experiment-tracking, nvidia, quantum

# devqubit-cudaq

[![PyPI](https://img.shields.io/pypi/v/devqubit-cudaq)](https://pypi.org/project/devqubit-cudaq/)

NVIDIA CUDA-Q adapter for [devqubit](https://github.com/devqubit-labs/devqubit) — automatic kernel capture, target snapshots, and result logging for CUDA-Q `sample` and `observe` workflows.

> [!IMPORTANT]
> **This is an internal adapter package.** Install via `pip install "devqubit[cudaq]"` and use the `devqubit` public API.

## Installation

```bash
pip install "devqubit[cudaq]"
```

## Usage

### Sampling

```python
import cudaq
from devqubit import track

@cudaq.kernel
def bell():
    q = cudaq.qvector(2)
    h(q[0])
    x.ctrl(q[0], q[1])
    mz(q)

with track(project="cudaq-experiment") as run:
    executor = run.wrap(cudaq)
    result = executor.sample(bell, shots_count=1000)
```

### Observe (Expectation Values)

```python
from cudaq import spin

hamiltonian = spin.z(0)

with track(project="cudaq-vqe") as run:
    executor = run.wrap(cudaq)
    result = executor.observe(bell, hamiltonian)
    print(result.expectation())
```

## What's Captured

| Artifact | Kind | Role |
|---|---|---|
| Kernel JSON | `cudaq.kernel.json` | `program` |
| Kernel diagram | `cudaq.kernel.diagram` | `program` |
| MLIR (Quake) | `cudaq.kernel.mlir` | `program` |
| QIR | `cudaq.kernel.qir` | `program` |
| Counts / expectation | `result.cudaq.output.json` | `result` |
| Execution envelope | `devqubit.envelope.json` | `envelope` |

## Documentation

See the [Adapters guide](https://devqubit.readthedocs.io/en/latest/guides/adapters.html) for details on `observe` workflows, performance tuning, and spin operator capture.

## License

Apache 2.0
devqubit-cirq 0.1.12
devqubit adapter for Cirq
Requires Python: <3.14,>=3.11
Keywords: cirq, experiment-tracking, quantum

# devqubit-cirq

[![PyPI](https://img.shields.io/pypi/v/devqubit-cirq)](https://pypi.org/project/devqubit-cirq/)

Google Cirq adapter for [devqubit](https://github.com/devqubit-labs/devqubit) — automatic circuit capture, simulator snapshots, and result logging for Cirq samplers and simulators.

> [!IMPORTANT]
> **This is an internal adapter package.** Install via `pip install "devqubit[cirq]"` and use the `devqubit` public API.

## Installation

```bash
pip install "devqubit[cirq]"
```

## Usage

```python
import cirq
from devqubit import track

q0, q1 = cirq.LineQubit.range(2)
circuit = cirq.Circuit([
    cirq.H(q0),
    cirq.CNOT(q0, q1),
    cirq.measure(q0, q1, key="result"),
])

with track(project="cirq-exp") as run:
    simulator = run.wrap(cirq.Simulator())
    result = simulator.run(circuit, repetitions=1000)
```

### Parameter Sweeps

```python
import sympy

theta = sympy.Symbol("theta")
circuit = cirq.Circuit([
    cirq.Ry(theta).on(q0),
    cirq.measure(q0, key="m"),
])

with track(project="sweep") as run:
    simulator = run.wrap(cirq.Simulator())
    sweep = cirq.Linspace("theta", 0, 2 * 3.14159, 10)
    results = simulator.run_sweep(circuit, sweep, repetitions=100)
```

## What's Captured

| Artifact | Kind | Role |
|---|---|---|
| Cirq JSON | `cirq.circuit.json` | `program` |
| Circuit diagram | `cirq.circuits.txt` | `program` |
| Measurement counts | `result.counts.json` | `result` |
| Device properties | `device.cirq.raw_properties.json` | `device_raw` |
| Execution envelope | `devqubit.envelope.json` | `envelope` |

## Documentation

See the [Adapters guide](https://devqubit.readthedocs.io/en/latest/guides/adapters.html) for parameter sweeps, performance tuning, and batch execution.

## License

Apache 2.0
devqubit-braket 0.1.12
devqubit adapter for Braket
Requires Python: <3.14,>=3.11
Keywords: braket, experiment-tracking, quantum

# devqubit-braket

[![PyPI](https://img.shields.io/pypi/v/devqubit-braket)](https://pypi.org/project/devqubit-braket/)

Amazon Braket adapter for [devqubit](https://github.com/devqubit-labs/devqubit) — automatic circuit capture, device property snapshots, and result logging for Braket local simulators and managed QPUs.

> [!IMPORTANT]
> **This is an internal adapter package.** Install via `pip install "devqubit[braket]"` and use the `devqubit` public API.

## Installation

```bash
pip install "devqubit[braket]"
```

## Usage

```python
from braket.circuits import Circuit
from braket.devices import LocalSimulator
from devqubit import track

circuit = Circuit().h(0).cnot(0, 1)

with track(project="braket-exp") as run:
    device = run.wrap(LocalSimulator())
    task = device.run(circuit, shots=1000)
    result = task.result()
```

## What's Captured

| Artifact | Kind | Role |
|---|---|---|
| OpenQASM 3 | `source.openqasm3` | `program` |
| Circuit diagram | `braket.circuits.diagram` | `program` |
| Measurement counts | `result.counts.json` | `result` |
| Raw result | `result.braket.raw.json` | `result_raw` |
| Device properties | `device.braket.raw_properties.json` | `device_raw` |
| Execution envelope | `devqubit.envelope.json` | `envelope` |

## Documentation

See the [Adapters guide](https://devqubit.readthedocs.io/en/latest/guides/adapters.html) for details on wrapping options, batch execution, and performance tuning.

## License

Apache 2.0
bluesky-tiled-plugins 2.0.2
Integrations for using Tiled with Bluesky
Requires Python: >=3.10

# bluesky-tiled-plugins

[![Actions Status][actions-badge]][actions-link]

[![PyPI version][pypi-version]][pypi-link]
[![Conda-Forge][conda-badge]][conda-link]
[![PyPI platforms][pypi-platforms]][pypi-link]

<!-- SPHINX-START -->

<!-- prettier-ignore-start -->
[actions-badge]:            https://github.com/bluesky/bluesky-tiled-plugins/workflows/CI/badge.svg
[actions-link]:             https://github.com/bluesky/bluesky-tiled-plugins/actions
[conda-badge]:              https://img.shields.io/conda/vn/conda-forge/bluesky-tiled-plugins
[conda-link]:               https://github.com/conda-forge/bluesky-tiled-plugins-feedstock
[pypi-link]:                https://pypi.org/project/bluesky-tiled-plugins/
[pypi-platforms]:           https://img.shields.io/pypi/pyversions/bluesky-tiled-plugins
[pypi-version]:             https://img.shields.io/pypi/v/bluesky-tiled-plugins

<!-- prettier-ignore-end -->

<!-- README only content. Anything below this line won't be included in index.md -->

See https://blueskyproject.io/bluesky-tiled-plugins for more detailed
documentation.