semvec/pypi-packages huggingface dataset:
saksin 0.1.4
Python SDK for querying Saksin AI chunked retrieval API
Requires Python: >=3.6

# saksin-vect2

SDK for accessing **Sākṣin Vector Database** APIs – designed to simplify querying and managing vectorized document chunks from Saksin’s intelligent retrieval system.

![PyPI](https://img.shields.io/pypi/v/saksin-vect2)
![Python](https://img.shields.io/pypi/pyversions/saksin-vect2)
![License](https://img.shields.io/github/license/kishanravi887321/saksin-vect2)

---

## ✨ Features

- Simple interface to interact with Saksin's document retriever.
- Query vectorized chunks through clean abstraction.
- Handles authorization and HTTP communication.
- Integrates easily with LangChain or any LLM application.

---

## 📦 Installation

```bash
pip install saksin-vect2
pinocchiout 0.3.0
Pinout solver STM32 for microcontrollers
Requires Python: >=3.13

# `pinocchiout` - STM32 Pinout Solver

![screenshot](https://raw.githubusercontent.com/mawildoer/pinocchiout/refs/heads/main/screenshot.png)

## Installation

I recommend using [`uv`](https://docs.astral.sh/uv/getting-started/installation/) to install this project.

Then, all you need to do is run `uvx pinocchiout` and it'll handle the rest.

## Usage

### With a `reqs.yaml/json` file

`reqs.yaml/json` is a simple file describing the requirements of your project.

```yaml title="reqs.yaml"
chip: STM32G431C6
package: UFQFPN48
requirements:
  - name: position-sensor
    kind: spi
    signals:
      - MOSI
      - MISO
      - SCK

reserved_pins:
 - PB8  # boot select pin

```

This one, for example, says you're trying to find a pinout for the STM32G431C6 microcontroller, in the UFQFPN48 package, with a SPI peripheral. It also reserves the boot select pin, PB8.

YAML is preferred, because it allows for comments, but JSON is also supported:

```json title="reqs.json"
{
    "chip": "STM32G431C6",
    "package": "UFQFPN48",
    "requirements": [
        {
            "name": "spi",
            "peripheral": "spi",
            "kind": "spi",
            "signals": ["MOSI", "MISO", "SCK"]
        }
    ]
}
```

You can print out a table of the pinout like so:

```bash title="Printing the pinout"
uvx pinocchiout solve --reqs "examples/reqs.yaml"
```

### Listing peripherals

You can also list all available peripherals for a chip/package:

```bash title="Listing peripherals"
uvx pinocchiout list --reqs "examples/reqs.yaml"
# or specify chip and package directly
uvx pinocchiout list --chip STM32G431C6 --package UFQFPN48
```

Peripheral names ("peripheral") and signal names ("signals") are treated as regular expressions, so you can use them to match multiple.

### As a library

Honestly, it could be better, but see `example.py` for a simple example of how to use it as a library.
pdate_cli 0.1.0
PDate converts dates to human-readable formats.
Requires Python: <4.0,>=3.12

# PDate

PDate make dates and times human-readable.

## Install

```bash
pip install pdate
```

## Features

### Quick check

```bash
$ pdate --now
1753307983

$ pdate --now --date
Wednesday, July 23, 2025 05:04:09 PM CDT
```

### Convert: flexible input formats

```bash
# Most formats accepted, e.g. ISO-8601, RFC-2822, etc.

$ pdate 2024-11-25T20:10:46Z
Monday, November 25, 2024 02:10:46 PM CST

$ pdate 12 hours ago
Wednesday, July 23, 2025 12:07:13 AM CDT
```

### Convert: choice of output format

```bash
$ pdate 2024-11-25T20:10:46Z --human
7 months ago

$ pdate 2024-11-25T20:10:46Z --precise
7 months, 26 days, 1 hour, 58 minutes and 24.89 seconds ago

$ pdate 2024-11-25T20:10:46Z --date --precise
Monday, November 25, 2024 02:10:46 PM CST
7 months, 26 days, 1 hour, 58 minutes and 46.01 seconds ago
```

### Batch: read from stdin, sort, etc.

```bash
$ echo 100000000 | pdate
Saturday, March 03, 1973 03:46:40 AM CST

$ echo -e '2024-11-25T20:10:46Z\n2024-11-25T20:10:46Z\n100000000' | pdate --sort
Saturday, March 03, 1973 03:46:40 AM CST
Monday, November 25, 2024 02:10:46 PM CST
Monday, November 25, 2024 02:10:46 PM CST
```

## Help pages

```text
$ pdate --help
Usage: pdate [OPTIONS] [ARG]...

  Parse ARG and format it as a local, human-readable date.

  If ARG is missing
  - If --now: print current date (default format: Unix timestamp)
  - Else: read from stdin (default format: human-readable date)

  Supported ARG formats
  - Most date formats, e.g. ISO-8601, RFC-2822, etc.
  - Unix timestamp

  Timezone considerations
  - For dates without timezone info, UTC is assumed
  - For timestamps, local timezone is assumed

Options:
  --now       Print just current date.
  --ts        Format output as Unix timestamp.
  --date      Format output as human-readable date.
  --human     Format output as human-readable date.
  --precise   Format output as precise human-readable date.
  --verbose   Print debug information.
  --sort      Sort output by date. Implies --stdin.
  --12        Use 12-hour format.
  -h, --help  Show this message and exit.
```
query-farm-airport-test-server 0.1.1
An Apache Arrow Flight server that is used to test the Airport extension for DuckDB.
Requires Python: >=3.12

# query-farm-airport-test-server

**`query-farm-airport-test-server`** is a Python module that implements a lightweight in-memory Arrow Flight server for use with the [Airport DuckDB extension](https://airport.query.farm). It showcases nearly all of the Airport extension's capabilities and is designed primarily for testing and CI integration.

> ⚠️ This server is not intended as a tutorial or reference for writing Arrow Flight servers from scratch. Its purpose is to comprehensively test feature coverage, and the implementation reflects that complexity.

## Features

- In-memory storage — no persistent state
- Accepts any authentication token
- Supports full reset of data via client call
- Ideal for CI pipelines and integration tests

## Installation

```sh
pip install query-farm-airport-test-server
```

## Usage

```sh
$ airport_test_server
```

Once running, the server can be used with the test suite included in the Airport DuckDB extension.