semvec/pypi-packages huggingface dataset:
varanus 0.1.0
Django application monitoring.
Requires Python: >=3.11

# Varanus

## Installation

```
pip install varanus
```

## Quickstart for Django

In your `settings.py`:

```python
try:
    import varanus.client
    varanus.client.setup(
        "https://APIKEY@varanus.example.com",
        environment=os.getenv("VARANUS_ENV", "local"),
        install=MIDDLEWARE,
    )
except ImportError:
    pass
```

For more information about how to configure the Varanus client, see [the configuration docs](docs/configuration.md). If nothing else, note that when using uWSGI, you'll need to enable threads with the [enable-threads](https://uwsgi-docs.readthedocs.io/en/latest/Options.html#enable-threads) option.
ci-cd-apier 2.0.0
ci-cd-APIer -- Flask-like API framework for GitLab CI/CD pipelines

# ci-cd-APIer

APIer is a library that allows you to launch its backend code with Flask-like syntax using GitLab CI/CD.
All the requests and responses are processed with e2e encryption using [age](https://age-encryption.org/),
so nobody has access to the data except the sender (web page) and the receiver (GitLab job in memory).

## Usage example

**To see the full example, take a look at the [example repository](https://gitlab.com/esoadamo/ci-cd-apier-example/).**

Whenever the client calls a backend via APIer script, e.g.:

```js
const APIer = new APIer(
    '$AGE_PUBLIC_KEY$',
    '$GITLAB_PIPELINE_ENDPOINT$',
    '$GITLAB_TOKEN$'
);

const totalSum = await APIer.sendRequest('sumNumbers', [1, 2, 3, 4, 5]);
```

A pipeline is triggered. Example code that handles the request in the pipeline may be:

```python
app = APIER(environ["AGE_SECRET_KEY"])

@app.route("echo")
def endpoint_echo(data: any) -> str:
    return f"You said: {data}. Enjoy :)"
    
@app.route("sumNumbers")
def endpoint_sum(data: list[int]) -> str:
    return str(sum(data))

app.process_requests()
```

There also exists Python client for APIer in `ci_cd_apier.client` package.
cf53 0.1.3
Cloudflare DNS client for humans
Requires Python: >=3.13

# cf53

A human-oriented cloudflare DNS updater. This provide a way to IaC cloudflare DNS records with a simple toml file, and get a good visual feedback of the diffs to make it actual.

Think terraform, but smarter. No need to keep a local state or copy/paste ids around, just say what records you want, provide an API token, that's it.
printserver 2.4.5
The missing JavaScript Printer API
Requires Python: >=3.9

# Installing Homebrew

    $ mkdir ~/Code; cd ~/Code; git clone git@gitlab.com:shortstory/print-server.git
    $ /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install.sh)"

# Running the Print Server

    $ make run
foundry-client 2.0.0
Python client for FoundryNet - Universal DePIN Protocol for Work Settlement on Solana
Requires Python: >=3.8

# foundry-client

Python client for FoundryNet - Universal DePIN Protocol for Work Settlement on Solana.

## Installation
```bash
pip install foundry-client
```

## Quick Start
```python
from foundry_client import FoundryClient

client = FoundryClient()
client.init()

# Register machine (one-time)
client.register_machine()

# Submit jobs
job_hash = client.generate_job_hash("work-content")
client.record_job(job_hash, duration_seconds=3600)
```

## Links

- [GitHub](https://github.com/FoundryNet/foundry_net_MINT)
- [Documentation](https://foundrynet.io)
- [Dashboard](https://foundrynet.github.io/foundry_net_MINT/)

## License

MIT
tilt-py 0.1.2
Python client for processing and sending data to Tilt's distributed computing platform
Requires Python: >=3.10

# Tilt Python Client

This is the official Python client for submitting and processing data in the [Tilt](https://tilt.technology) distributed computing platform.

## 🚀 Overview

Tilt enables distributed data processing by orchestrating multiple devices connected to a network.
This client is responsible for reading input files, batching the content, and sending it to the Tilt API asynchronously.

## 📦 Installation

```bash
pip install tilt-py
```

## 🧑‍💻 Usage

```python
import os
from uuid import UUID

from tilt import Options, Tilt
from tilt.source_handler import TextSourceHandler
from tilt.types import Some

# Load environment variables or set directly
SECRET_KEY = os.getenv("SECRET_KEY")  # or "your_secret_key"
PROGRAM_ID = UUID("c6e024e0-ad75-45ca-94b4-bbeadb4eebfa")  # Replace with your program ID
INPUT_FILE = "shipping_calculation.jsonl"  # Path to your input file

# Configure data source and options
data_src = TextSourceHandler(INPUT_FILE)
options = Options(
    data_src=Some(data_src),
    program_id=Some(PROGRAM_ID),
    secret_key=Some(SECRET_KEY),
)

# Create Tilt instance and run processing
tilt = Tilt(options)
results = tilt.create_and_poll()

# Process results
texts = []
for _, item in results:
    if item is not None:
        texts.append(item.value.decode())

print(" ".join(texts))
```

The client reads from the configured data source, batches the input, and sends it to the Tilt API for processing.

## ✅ Requirements

- Python 3.10+

## Common Issues & Fixes

### SSL Certificate Verification Error on macOS

If you encounter the following error when running the application:

```
ssl.SSLCertVerificationError: [SSL: CERTIFICATE_VERIFY_FAILED] certificate verify failed: unable to get local issuer certificate
```

This is a common issue on macOS with Python installations (especially Python 3.10+), as the default Python does not automatically use the system's certificate store.

**Solution**

Run the official Python certificate installer (recommended):

```bash
/Applications/Python\ 3.13/Install\ Certificates.command
```

This command installs the Mozilla root certificates bundle and updates the Python trust store.

Alternatively, if the command is not available (e.g., Homebrew, pyenv, or custom installation), update the `certifi` package:

```bash
pip install --upgrade certifi
```

After running either of these, restart your terminal or Python process and try again:

```bash
python -m tilt.main
```

This should resolve the `ClientConnectorCertificateError` and allow the application to connect to `staging.tilt.rest` successfully.
zeroheliumkit 0.5.5
--
Requires Python: >=3.11

# ZeroHeliumKit

<p align="center">
<img src="docs/source/_static/zhk.png" alt="zhk_logo" width="350"/>
</p>


ZeroHeliumKit is a Python module for planar geometry creation and manipulations designed for building microfabricated chips, and integrated electric field calculations. ZeroHeliumKit allows to create complex structure designs from simple geometries and assemble them in an intuitive Lego-style level. Geometry creation and assembly part is based on [Shapely](https://github.com/shapely/shapely) python package, which provides fast boolean operations on geometrical objects. ZeroHeliumKit enables simple integration with [Gmsh](https://gmsh.info) (mesh generation toolkit) and [FreeFEM++](https://freefem.org) (finite element solver for partial differential equations) to perform electric field calculations on designed geometrical structures.


## Documentation

The complete documentation (with examples) is available [here](https://zeroheliumkit.readthedocs.io/en/latest/).


## Installing

After cloning repository, `cd` into the new directory and install neseccary packages:
```shell
pip install -r requirements.txt
```
Note, if you are on Windows or Mac and don’t already have `gdspy` installed, you will need a C++ compiler (in case if you have an error in installing this package):
* for Windows + Python 3, install the Microsoft [“Build Tools for Visual Studio”](https://visualstudio.microsoft.com/downloads/#build-tools-for-visual-studio-2019)
* For Mac, install “Xcode” from the App Store, then run the command `xcode-select --install` in the terminal

Next, install `zeroheliumkit` into your environment: 
```
pip install -e .
```
You can now open your python and run `import zeroheliumkit`. The final step is to install the latest FreeFEM++ software, which can be found [here](https://github.com/FreeFem/FreeFem-sources/releases).

## Usage

The easiest way to learn is through [examples](docs/source/notebooks/)

Creating anchors and routes [basics](docs/source/notebooks/basics.ipynb):
<p align="center">
<img src="docs/source/_static/anchors_routes.png" alt="zhk_logo" width="500"/>
</p>

Creating mesh and Caculating electrostatic potential distribution [fem](docs/source/notebooks/gmsh+fem.ipynb):
<p align="center">
<img src="docs/source/_static/fig1.png" alt="zhk_logo" width="500"/>
</p>
quisk 4.2.50
QUISK is a Software Defined Radio (SDR) transceiver that can control various radio hardware.

QUISK is a Software Defined Radio (SDR) transceiver.  
You supply radio hardware that converts signals at the antenna to complex (I/Q) data at an
intermediate frequency (IF). Data can come from a sound card, Ethernet or USB. Quisk then filters and
demodulates the data and sends the audio to your speakers or headphones. For transmit, Quisk takes
the microphone signal, converts it to I/Q data and sends it to the hardware.

Quisk can be used with SoftRock, Hermes Lite 2, HiQSDR, Odyssey and many radios that use the Hermes protocol.
Quisk can connect to digital programs like Fldigi and WSJT-X. Quisk can be connected to other software like
N1MM+ and software that uses Hamlib.
pyprodos 0.4.0
Python implementation of Apple ProDOS 8 file system
Requires Python: >=3.11
Keywords: prodos, filesystem

pyprodos
---

This is a simple Python implementation of the Apple ProDOS :tm: filesystem based on the
[technical reference manual](https://prodos8.com/docs/techref/file-organization/).

It provides a simple unix-style CLI for managing existing ProDOS images in 
`.po` and `.2mg` files and for creating new ones.
This provides an accessible file system for Apple // or other 8-bit hardware. 

As an example, let's recreate a ProDOS boot volume.  Grab the ProDOS 2.4.3
boot disk from https://prodos8.com/.  (There's a copy in `images/` here.)
Check what's on it:

    % prodos info images/ProDOS_2_4_3.po

    Volume PRODOS.2.4.3 23-12-29T19:07
    BlockDevice on images/ProDOS_2_4_3.po contains 280 total blocks, 26 free (91% used)

    % prodos ls images/ProDOS_2_4_3.po

    File name               EOF T/FT Access Created        Modified      Blocks @ Key
    ---------------------------------------------------------------------------------
    VIEW.README             512 1/FC RW-BND 18-02-13T09:09 18-02-13T09:09     1 @ 250
    ...
    BASIC.SYSTEM          10240 2/FF RW-BND 23-12-30T02:43 23-12-30T02:43    21 @ 42
    ...
    PRODOS                17128 2/FF RW-BND 23-12-30T02:43 23-12-30T02:43    34 @ 7
    README                  999 2/04 RW-BND 23-12-30T02:43 23-12-30T02:43     3 @ 251
        17 files in PRODOS.2.4.3 F RW--ND 23-12-29T19:07

Let's extract the `PRODOS` o/s and `BASIC.SYSTEM` files, plus the bootloader.
ProDOS should execute the first `.SYSTEM` file it finds after it boots.

    % prodos export images/ProDOS_2_4_3.po /PRODOS /BASIC.SYSTEM . --loader loader.bin

Now we'll make a new 140K (280 block) floppy boot disk:

    % prodos create boot.po --name MYVOL --size 280

then import the system files and bootloader and check the listing:

    % prodos import boot.po --loader loader.bin PRODOS BASIC.SYSTEM /

    % prodos ls boot.po

    File name               EOF T/FT Access Created        Modified      Blocks @ Key
    ---------------------------------------------------------------------------------
    PRODOS                17128 2/FF RW-BND 25-12-28T15:20 25-12-28T15:20    34 @ 7
    BASIC.SYSTEM          10240 2/FF RW-BND 25-12-28T15:20 25-12-28T15:20    21 @ 41
        2 files in MYVOL F RW-BND 25-12-28T15:19

Finally, test the image in your favorite emulator.  I used [VirtualII](https://www.virtualii.com/) and popped my volume in the virtual Disk ][ drive.   After a ProDOS splash screen, you you see the familiar Basic prompt:

                PRODOS BASIC 1.7
            COPYRIGHT APPLE  1983-92

    ]

My original goal was to learn how the on-disk representation worked and to manage
disk images for a 6502-based breadboard computer.
ProDOS is simple enough that a minimal kernel
can be very small.  For example I use a read-only
version that's only a couple hundred lines of TaliForth.
I also ported a version of the original 6502
ProDOS filestyem kernel: [p8fs](https://github.com/patricksurry/p8fs).