semvec/pypi-packages huggingface dataset:
qiskit-quimb 0.0.10
Simulate Qiskit circuits using quimb
Requires Python: >=3.9

# qiskit-quimb

<!-- start introduction -->

Simulate [Qiskit](https://www.ibm.com/quantum/qiskit) circuits using [quimb](https://quimb.readthedocs.io/en/latest/).

<!-- end introduction -->

## Documentation

Documentation is located at the [project website](https://qiskit-community.github.io/qiskit-quimb/).

## Installation

<!-- start installation -->

```bash
pip install qiskit-quimb
```

<!-- end installation -->

## Usage

The `qiskit_quimb` module exposes three functions:

- `quimb_circuit`: Converts a Qiskit circuit to a quimb circuit.
- `quimb_gates`: Converts a Qiskit circuit to a list of quimb gates, which is a bit more flexible.
- `quimb_gate`: Converts a Qiskit gate to a quimb gate.

For details, refer to the [API documentation](https://qiskit-community.github.io/qiskit-quimb/api/qiskit_quimb.html).

## Code example

<!-- start code-example -->

```python
import quimb.tensor
from qiskit.circuit import QuantumCircuit, QuantumRegister
from qiskit_quimb import quimb_circuit

# Build a Qiskit circuit
qubits = QuantumRegister(2)
circuit = QuantumCircuit(qubits)
a, b = qubits
circuit.h(a)
circuit.cx(a, b)

# Convert it to a quimb circuit
quimb_circ = quimb_circuit(circuit)

# Sample 10 bitstrings
samples = list(quimb_circ.sample(10, seed=1234))
print(samples)

# You can specify the quimb Circuit subclass and keyword arguments for the constructor
quimb_circ = quimb_circuit(
    circuit, quimb_circuit_class=quimb.tensor.CircuitMPS, max_bond=20
)
samples = list(quimb_circ.sample(10, seed=1234))
print(samples)
```

```text
['00', '00', '11', '00', '11', '00', '11', '00', '11', '11']
['11', '11', '00', '00', '11', '00', '11', '11', '11', '00']
```

<!-- end code-example -->
pg0-embedded 0.12.0
Python API for pg0 - embedded PostgreSQL
Requires Python: >=3.8
Keywords: database, embedded, pgvector, postgresql

# pg0 - PostgreSQL for Python

[![PyPI](https://badge.fury.io/py/pg0-embedded.svg)](https://pypi.org/project/pg0-embedded/)

Zero-config PostgreSQL with pgvector. No installation, no Docker, no configuration.

## Install

```bash
pip install pg0-embedded
```

## Usage

```python
from pg0 import Pg0

# Basic usage
with Pg0() as pg:
    print(pg.uri)  # postgresql://postgres:postgres@localhost:5432/postgres
    pg.execute("CREATE EXTENSION IF NOT EXISTS vector")
    pg.execute("SELECT version()")

# Custom configuration
pg = Pg0(
    name="myapp",
    port=5433,
    username="myuser",
    password="mypass",
    database="mydb",
    config={"shared_buffers": "512MB"}
)
pg.start()
pg.stop()
```

## API

### Pg0 Class

| Method | Description |
|--------|-------------|
| `start()` | Start PostgreSQL, returns `InstanceInfo` |
| `stop()` | Stop PostgreSQL |
| `drop()` | Stop and delete all data |
| `info()` | Get instance info |
| `execute(sql)` | Run SQL query |
| `uri` | Connection URI (property) |
| `running` | Check if running (property) |

### Module Functions

```python
import pg0

pg0.start(name="default", port=5432, ...)  # Start instance
pg0.stop(name="default")                    # Stop instance
pg0.drop(name="default")                    # Delete instance
pg0.info(name="default")                    # Get instance info
pg0.list_instances()                        # List all instances
```

### Getting Connection URI

```python
from pg0 import Pg0

pg = Pg0()
pg.start()

# Using the uri property
print(pg.uri)  # postgresql://postgres:postgres@localhost:5432/postgres

# Or using info()
info = pg.info()
print(info.uri)  # postgresql://postgres:postgres@localhost:5432/postgres
print(info.port)  # 5432
print(info.username)  # postgres
print(info.database)  # postgres
```

## Supported Platforms

Pre-built wheels are available for:

| Platform | Architecture | Wheel Tag |
|----------|--------------|-----------|
| macOS | Apple Silicon (M1/M2/M3) | `macosx_14_0_arm64` |
| Linux | x86_64 (glibc) | `manylinux_2_35_x86_64` |
| Linux | ARM64 (glibc) | `manylinux_2_35_aarch64` |
| Windows | x64 | `win_amd64` |

For other platforms, install from source (requires Rust toolchain):
```bash
pip install pg0-embedded --no-binary pg0-embedded
```

## Links

- [GitHub](https://github.com/vectorize-io/pg0)
- [CLI Documentation](https://github.com/vectorize-io/pg0#readme)
bdpan 1.5.0
A small Baidu Netdisk tool.
Requires Python: >=3.9

# bdpan

一个可复用的百度网盘（pan.baidu.com）小库，支持：

- 目录递归上传
- 分片并发上传（默认 4MB 分片、4 线程）
- 断点续传（本地保存 upload state）
- 创建分享链接（通过 `api/filemetas` 获取 `fs_id`）

## 安装

在本仓库中可直接：

```bash
pip install -e .
```

## 准备 cookies

需要登录后的 cookies（至少包含 `BDUSS`/`STOKEN` 等）。支持两种格式：

- 形如 `key=value; key2=value2` 的 Cookie Header 文本
- 浏览器导出的 Netscape `cookies.txt`

## 使用（库）

```python
from bdpan import BaiduPanClient, BaiduPanConfig

client = BaiduPanClient(
    BaiduPanConfig(
        cookie_file="cookies.txt",
        remote_root="/apps/bdpan",
        state_dir="./data/bd_upload_state",
    )
)

client.upload("local_folder_or_file")
link = client.share("remote_dir_name", password="1234", period_days=7)
print(link)
```

## 使用（命令行）

```bash
bdpan --cookie-file .\\auth\\baidu\\cookies.txt upload .\\data
bdpan --cookie-file .\\auth\\baidu\\cookies.txt share remote_dir --password 1234 --period-days 7
```

## 本地验证

```bash
python -m unittest discover -s tests -p "test_*.py"
```
rcdl 3.0.0b32
Coomer/Kemono CLI Downloader
Requires Python: >=3.12
Keywords: downloader, video, media

# RCDL

Riton Coomer Download Manager  
`rcdl` is a tool to automatically download the videos of your favorites creators from [coomer.st](https://coomer.st) and [kemono.cr](https://kemono.cr)


## Install
### Dependencies
- [yt-dlp](https://github.com/yt-dlp/yt-dlp)
- [aria2](https://github.com/aria2/aria2)
- [ffmpeg](https://www.ffmpeg.org/download.html) (Only for `fuse` command)  
- [HandBrakeCLI](https://handbrake.fr/docs/en/latest/cli/cli-options.html) (Only for `opti` command)
Recommended install:
```bash
pipx install yt-dlp streamlit
sudo apt update
sudo apt install aria2 ffmpeg handbrake-cli python3-tk
```
### Install RCDL
It is recommended to use `pipx` to install `rcdl`
```bash
pipx install rcdl
```
or else:  
```bash
pip install rcdl
```

## How to use

Run the CLI with:

```bash
rcdl --help
```

By default all files will live in `~/Videos/rcdl/`. Cache, configuration and log file will be in a hidden `rcdl/.cache/` folder.

Main function:  
```bash
rcdl refresh    # look creators.json and find all possible videos
rcdl dlsf       # download all found videos
rcdl discover   # Discover new creator (WIP)
rcdl opti       # Optimized video to reduce disk storage usage
rcdl fuse       # Fuse all videos within a same post if they are fully downloaded
```

Manage creators:  
```bash
rcdl list   # list all current creators
rcdl add [URL]
rcdl add [service]/[creator_id]
rcdl remove [creator_id]
```

Helper function:  
```bash
rcdl status     # give number of entry in the database per tables and status
rcdl clean --all      # remove all partially downloaded file, external dependencies cache, etc...
rcdl show-config        # print all config var and theirs value (paths, etc...)
```

### Settings
Default settings file:
```toml
[app]
default_max_page = 10
max_fail_count = 7
timeout = 10

[fuse]
max_width = 1920
max_height = 1080
fps = 30
preset = "veryfast"
threads = 0

[paths]
base_dir = "~/Videos/rcdl"
handbrake_run_cmd = "HandBrakeCLI"
```

In `rcdl/.cache/config.toml`:
```toml
[paths]
handbrake_run_cmd = "HandBrakeCLI"  # if installed via apt
handbrake_run_cmd = "flatpak run --command=HandBrakeCLI fr.handbrake.ghb"   # if installed via flatpak
```

## Dev
### Install
```bash
git clone https://github.com/ritonun/cdl.git rcdl
cd rcdl
python3 -m venv .venv
source .venv/bin/activate
pip install -e .
```

## Deploy
```bash
python3 -m pip install --upgrade build
python3 -m pip install --upgrade twine
```
kywy 0.34.10
Python client for Kawa - https://docs.kawa.ai
Requires Python: >=3.9

## KYWY is the official KAWA Python client

This project allows to connect to a KAWA instance to perform various data analytics tasks:

- Uploading data to a data warehouse
- Performing computations on the data warehouse managed by Kawa
- Managing advanced administration settings for KAWA administrators

Please visit our website for additional information and contact: https://www.kawa.ai

## Usage
The full documentation can be found here: https://github.com/kawa-analytics/kywy-documentation

## Dev setup
Make sure to create a .env file at the root of the project with the following content:

```
# Connection to KAWA configuration
# (Used for the scripts in the cloud directory)
KAWA_URL=http://127.0.0.1:8080
KAWA_API_KEY=****
KAWA_WORKSPACE=1

# E2E test configuration
# (Used to run the E2E tests)
E2E_KAWA_URL=http://127.0.0.1:8080
E2E_KAWA_API_KEY_USER_1=****
E2E_KAWA_API_KEY_USER_2=***
E2E_KAWA_WORKSPACE=1
```
satellitic 0.1.15
A collection of satellite methods and approaches to satellite simulations
Requires Python: >=3.11

# Satellitic
A collection of tools for satellite assessments

[![License](https://img.shields.io/github/license/Qiskit/qiskit.svg?)](https://opensource.org/licenses/Apache-2.0)
[![PyPI Downloads](https://static.pepy.tech/personalized-badge/satellitic?period=total&units=INTERNATIONAL_SYSTEM&left_color=BLACK&right_color=GREEN&left_text=downloads)](https://pepy.tech/projects/satellitic)

## Install
Install the package using :
```
pip install satellitic
```

## Example
In order to create a similar image as this:
![text](https://raw.githubusercontent.com/pts-rictjo/satellitic/674bec3d24d930ecb37ec6bdce9e4cd7c238a03e/examples/cofreq_heatmap.png)

place the content of this projects data folder in you run root and execute the below code
```
from satellitic.init import ALL_CELESTRAK_GROUPS,PREFERRED_BANDS
import satellitic.simulation as satsim

out = satsim.run_snapshot_simulation(
            out_dir="sim_20251212_dev",
            groups=ALL_CELESTRAK_GROUPS,	# CELESTRAK_GROUPS,
            local_tle_file="tle_local.txt", 	# LOCAL_TLE_FALLBACK,
            N_target=10000,               	# set to 35000 for full-scale runs (ensure resources)
            grid_nlat=120,
            grid_nlon=240,
            model="multibeam",
            n_beams_per_sat=7,
            beam_half_angle_deg=0.8,
            beam_pattern="hex",
            beam_max_tilt_deg=10.0,
            beam_gain_model="gaussian",
            gain_threshold=0.25,
            frequency_band="E-band",
            preferred_bands=PREFERRED_BANDS,
            chunk_sat=256,
            chunk_ground=20000,
            use_gpu_if_available=False,   # set True if you installed cupy
            compute_power_map = False,
            do_random_sampling = True,
        )
print("Simulation finished. Outputs:", out)

import pandas as pd
tdf = pd.concat( ( pd.read_csv(out['total_csv']),	pd.read_csv(out['pref_csv']), pd.read_csv(out['cofreq_csv']),	pd.read_csv(out['nvis_csv'])) )
print ( tdf .describe() )
```

# Forcing qt5 in VisPy
```
>>> from vispy import app
... print(app.use_app('pyqt5', True))  # force PyQt5
```
# To view an orbital simulation
Note that the streaming 3D vispy visualisation cannot handle huge amounts of satellites. Test with a small tle file and then offload to the trajectory file
```
>>> from satellitic.simulation import newtonian_simulator
ImportSuccess: HAS JAX IN ENVIRONMENT
>>> newtonian_simulator(bAnimated=True, tle_file_name='data/local_small_tle.txt')
```
To write a trajectory file you can specify
```
>>> newtonian_simulator(bAnimated=False, tle_file_name='data/local_small_tle.txt' , Nsteps=10000 )
```