semvec/pypi-packages huggingface dataset:
wheel 0.46.3
Command line tool for manipulating wheel files
Requires Python: >=3.9
Keywords: wheel, packaging

wheel
=====

This is a command line tool for manipulating Python wheel files, as defined in
`PEP 427`_. It contains the following functionality:

* Convert ``.egg`` archives into ``.whl``
* Unpack wheel archives
* Repack wheel archives
* Add or remove tags in existing wheel archives

.. _PEP 427: https://www.python.org/dev/peps/pep-0427/

Historical note
---------------

This project used to contain the implementation of the setuptools_ ``bdist_wheel``
command, but as of setuptools v70.1, it no longer needs ``wheel`` installed for that to
work. Thus, you should install this **only** if you intend to use the ``wheel`` command
line tool!

.. _setuptools: https://pypi.org/project/setuptools/

Documentation
-------------

The documentation_ can be found on Read The Docs.

.. _documentation: https://wheel.readthedocs.io/

Code of Conduct
---------------

Everyone interacting in the wheel project's codebases, issue trackers, chat
rooms, and mailing lists is expected to follow the `PSF Code of Conduct`_.

.. _PSF Code of Conduct: https://github.com/pypa/.github/blob/main/CODE_OF_CONDUCT.md
toxicdev 0.0.1
High-speed uploading & downloading toolkit for Telegram using Telethon
Requires Python: >=3.6

🚀 **High-speed uploading & downloading toolkit for Telegram using Telethon**

`toxicdev` is a Python library designed for **fast, reliable uploads and downloads on Telegram**, supporting **both user accounts and bots** via Telethon.  
It is optimized for performance and simplicity, making it suitable for automation tools, bots, and Telegram-based utilities.

---

## ✨ Features

- ⚡ Fast uploading & downloading
- 🤖 Supports **Telegram Bots** and **User Accounts**
- 🔐 Built on **Telethon**
- 📁 Async file handling with `aiofiles`
- 🧩 Easy to integrate into existing projects
- 🖥️ OS independent

---

## 📦 Installation

Install directly from PyPI:

```bash
pip install toxicdev
mtproto-mitm 0.2.4
Telegram mtproto mitm server.
Requires Python: <4.0,>=3.11

# MTProto MITM server

Telegram mtproto mitm server.<br>

**This project must be used for research purposes only.**

## Installation
**Requirements:**
  - Python 3.11+

```shell
pip install mtproto-mitm
```

# TODO
  - [ ] Record mtproto connections to files to allow reviewing them later
  - [x] Add cli interface
  - [ ] Add web interface ?

## Usage

1. Install mtproto-mitm
2. Get your telegram auth key:
    - Telethon or Pyrogram: you need session file and any sqlite reader. Open session file with sqlite reader and run "SELECT HEX(auth_key) FROM sessions;"
    - Telegram for Android (not Telegram X): you need root access. Copy tgnet.dat file from telegram directory (/data/data/\<package name\>/files/tgnet.dat) from your android device to your pc. Now you can use [tgnet](https://github.com/RuslanUC/tgnet) to extract key: use code from [example](https://github.com/RuslanUC/tgnet).
    - Telegram Desktop: you can use [opentele](https://github.com/thedemons/opentele) to extract auth key from tdata folder. From Telegram Desktop version 5 and newer, seems like Telegram uses exclusively temp auth keys that are generated at runtime and not stored anywhere; that means once you close Telegram Desktop application, you won't be able to access decryption keys, so you need to extract them from memory while Telegram is running, and only then start mtproto-mitm with those keys; also, note that temp keys work for at most 1 day (iirc) and even if you won't restart Telegram application, you'll need to extract keys again later. To extract keys from memory, you can use [tdesktop-keys-extract script](https://github.com/RuslanUC/tdesktop-keys-extract).
3. Run MTProto-MITM:

    ```shell
    Usage: python -m mtproto_mitm [OPTIONS]
    
    Options:
      -h, --host TEXT       Proxy host to run on.
      -p, --port INTEGER    Proxy port to run on.
      -k, --key TEXT        Hex-encoded telegram auth key.
      -f, --keys-file TEXT  File with telegram auth keys.
      -q, --quiet           Do not show requests in real time.
      -o, --output TEXT     Directory to which mtproto requests will be saved.
      --proxy-no-auth       Disable authentication for proxy.
      --proxy-user TEXT     Proxy user in login:password format.
      --help                Show this message and exit.
    ```

4. Set socks5 proxy settings on your telegram client to host/port/user you specified on last step.

## Examples
```shell
python -m mtproto_mitm --host 127.0.0.1 --port 1080 --key 0F5B...A38F --keys-file ./auth_keys
```
valohai-cli 0.35.0
Command line client for Valohai
Requires Python: >=3.9

# Valohai Command Line Client

![CI](https://img.shields.io/github/actions/workflow/status/valohai/valohai-cli/ci.yml?branch=master)
![Codecov](https://img.shields.io/codecov/c/github/valohai/valohai-cli.svg)
![PyPI](https://img.shields.io/pypi/v/valohai-cli.svg)
![MIT License](https://img.shields.io/github/license/valohai/valohai-cli.svg)

This is the command-line client for the [Valohai][vh] machine learning IaaS platform.

## Installation

`valohai-cli` supports Python 3.9 and higher.

- If you still need to run on Python 3.5, version 0.13.0 was the last one to support it.
- If you still need to run on Python 3.6, version 0.23.0 was the last one to support it.
- If you still need to run on Python 3.7, version 0.25.0 was the last one to support it.
- If you still need to run on Python 3.8, version 0.33.0 was the last one to support it.

### System-wide or user-wide installation with pipx

The recommended way to install `valohai-cli` system-wide is to use [`pipx`][pipx], an
utility to install and run Python applications in isolated environments.
(If you're familiar with Node.js's `npx` tool, it's the same idea.)

This ensures that `valohai-cli`'s dependencies don't conflict with other Python packages.

Once you have installed and configured `pipx` (see the link above), you can

```bash
$ pipx install valohai-cli
```

and to upgrade it later on,

```bash
$ pipx upgrade valohai-cli
```

### System-wide or user-wide installation with pip

You can also install `valohai-cli` system-wide with `pip`,
but this may cause conflicts with other Python packages installed
system-wide or user-wide.

```bash
$ pip3 install -U valohai-cli
```

The `-U` flag ensures that any present version is upgraded, too.

### Installation in a virtual environment

If you prefer to install `valohai-cli` in a virtual environment, you can do so with `pip` as well.

```bash
$ python3 -m venv venv
$ source venv/bin/activate
$ pip install -U valohai-cli
```

## Getting Started

After you've installed the client, `vh` should work and you should see a description
of commands.

See the [tutorial document](./TUTORIAL.md)!

[vh]: https://valohai.com/
[app]: https://app.valohai.com/

## Developing

Development requires Python 3.10+; otherwise you'll get false positive type failures.
CI will run tests on older Python versions.

To work on the `valohai-cli` code: pull the repository, create and activate a virtualenv, then run:

```bash
make dev
```

This installs `valohai-cli` as an "editable" `vh` command available in the virtualenv, but linked to
the working copy's source. That is, you can now edit the source under `valohai_cli` in your working
directory, and try it out with `vh`.

```bash
vh --help
# Usage: vh [OPTIONS] COMMAND [ARGS]...
```

To run lints, type checks and tests:

```bash
# run linting and type checks
make lint

# run tests
make test
```

[pipx]: https://github.com/pypa/pipx
pdflinkcheck-rust 0.1.14
Rust core for pdflinkcheck: fast PDF link & TOC extraction
Requires Python: >=3.10

# pdflinkcheck-rust

The high-performance Rust core for `pdflinkcheck`. This package provides native PDF analysis capabilities using PDFium via PyO3 bindings.

## Prerequisites

- **Rust & Cargo**: [Install here](https://rustup.rs/)
    
- **Python 3.10+**
    
- **Maturin**: `uv tool install maturin` or `pip install maturin`
    
- **libpdfium.so**: This project requires a compiled PDFium shared library.
    

## Project Structure

- `src/`: Rust source code (PyO3 bindings and analysis logic).
    
- `pdflinkcheck_rust/`: Python package wrapper.
    
- `pdflinkcheck_rust/libpdfium.so`: The PDFium binary (must be present for the engine to function).
    

## Development

To compile the Rust code and install the package into your current virtual environment:


```bash
# Ensure libpdfium.so is in pdflinkcheck_rust/
maturin develop
```

To run the standalone Rust CLI:


```bash
cargo build --release
./target/release/pdflinkcheck-rust <path_to_pdf>
```

## Environment Configuration

Because the Rust engine links to PDFium at runtime, you may need to point your library loader to the package directory during local testing:


```bash
export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$(pwd)/pdflinkcheck_rust
```

## Building for Distribution

To create a wheel for installation in other projects:


```bash
maturin build --release
```

The resulting wheel will be located in `target/wheels/`.