semvec/pypi-packages huggingface dataset:
camtty 0.1.1
A CLI tool to display webcam feed as ASCII art in the terminal
Requires Python: >=3.7
Keywords: webcam, ascii-art, terminal, cli, video, camera, ascii, tty

# Camtty 📸 -> 💻 -> 🎨

**Turn your webcam feed into live ASCII art directly in your terminal!**

Camtty is a fun command-line tool that captures video from your webcam, converts each frame into ASCII characters, and displays the result in real-time in your terminal.

![Camtty in Action 1](screenshots/Screenshot%202025-05-01%20at%2021.10.30.png)

## ✨ Features

*   **Live Webcam Feed:** See the world around you rendered in ASCII.
*   **Real-time Conversion:** Fast conversion process for a smooth experience.
*   **Terminal-Based:** Runs entirely within your terminal using libraries like `blessed`.
*   **Customizable (Future):** (Add potential future features like character set selection, resolution adjustment, etc.)

![Camtty Feature Example](screenshots/Screenshot%202025-05-01%20at%2021.13.52.png)

## 🚀 Installation

1.  **Prerequisites:**
    *   Python 3.7+
    *   `pip` (Python package installer)
    *   A connected webcam recognized by your system.

2.  **Install using pip:**
    *(Assuming your package is or will be published on PyPI)*
    ```bash
    pip install camtty
    ```
    *Alternatively, for local development:*
    ```bash
    # Clone the repository (if you haven't already)
    # git clone https://github.com/Aresga/Camtty.git
    # cd camtty
    pip install .
    ```

## 🎮 Usage

Simply run the following command in your terminal:

```bash
camtty
```

Press `Ctrl+C` to stop the stream.

![Camtty Usage Example](screenshots/Screenshot%202025-05-01%20at%2021.15.08.png)

## 🔧 How it Works

Camtty uses:

*   **OpenCV (`opencv-python`)**: To capture video frames from the webcam.
*   **NumPy**: For efficient numerical operations on image data.
*   **Blessed**: To control the terminal and display the ASCII art smoothly.

The core logic involves:
1.  Capturing a frame from the webcam.
2.  Resizing the frame (optional, for performance/fit).
3.  Converting the frame to grayscale.
4.  Mapping pixel intensity values to ASCII characters.
5.  Printing the resulting ASCII string to the terminal using `blessed` for positioning.

## 🤝 Contributing

Contributions are welcome! Please feel free to open an issue or submit a pull request.

## 📄 License

see the [LICENSE](LICENSE) file for details.
py-pixi 0.0.1
A Python package for program analysis and custom instruction generation
Requires Python: >=3.6

# Pixi (Pass for Instruction eXtraction and Inference)

[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
[![Python 3.8+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
[![pypi](https://github.com/JoyenBenitto/Pixi/actions/workflows/pypi.yml/badge.svg?branch=main)](https://github.com/JoyenBenitto/Pixi/actions/workflows/pypi.yml)

Pixi is a tool for analyzing LLVM IR and generating custom hardware instructions to optimize performance-critical code sections in the von-Neumann pipeline. The project follows the idea of everything is computation both hardware and software but they come with different computational cost models.

## Requirements

- Python 3.10+
- LLVM and Clang (automatically set up by the installation process)
- Ninja build system
- CMake 3.13.4+

## Installation

```bash
# Clone the repository
git clone https://github.com/JoyenBenitto/Pixi.git
cd Pixi

# Install the package in development mode
pip install -e .

# Set up LLVM dependencies
pixi setup -c <jobs>
```

>[!Note]
>The setup process clones and configures the LLVM project, which may take some time during the initial setup. Subsequent setups will be much faster.

## Usage

Pixi provides a comprehensive command-line interface for analyzing code, generating LLVM IR, and creating custom hardware instructions.

### Command Reference

| Command | Description |
|---------|-------------|
| `setup` | Sets up the LLVM environment for Pixi |


## License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
tscalc 2.0.1
A comprehensive assessment tool to evaluate personal attributes related to toughness, success potential, and personality type.
Requires Python: >=3.9

# Toughness Success Calculator (tscalc)

A comprehensive assessment tool to evaluate personal attributes related to toughness, success potential, and personality type.

## Features

- Comprehensive assessment across multiple domains.
- Detailed personality type analysis with strengths and challenges.
- Generate reports in JSON and PDF formats.
- Recommendations for personal and professional growth.
- Insights into success potential and mastery trajectory.

## Installation

```bash
pip install tscalc
```

## Usage

The tool is a CLI-based application. Run the following command to start the assessment:

```bash
tscalc
```
or make a file named tscalc.py or any name of your choosing.
and enter the following lines of code

```bash
from tscalc import take_quiz

take_quiz()
```
then type "python [file name].py" in CMD to execute

Follow the on-screen prompts to complete the assessment. After completing the assessment, you can save the results and export them as a PDF report.


## License

This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.
packaging-demo-bsahlas 0.0.4
udemy.com - TPP Course working with PyPI
Requires Python: >=3.8
Keywords: tpp, continuous delivery, python

# udemy-tpp-section-11
udemy.com
Taking Python to Production: A Professional Onboarding Guide
(TPP): Course concerning professional Python integration and usaged.

Section 11: Python Packaging for team and enterprise level work.

![Subject: Python Packaging](packaging_demo/images/Courses.png)

Notes on [TTP](https://docs.google.com/document/d/1lVpKSA0UrOvDcfk206z6mz_EJA39q2Cd93W8DB8QRas/edit?usp=sharing):

Snyk (sneek): Lookup python packages and see ratings, usage, etc. https://snyk.io/advisor/python

Packaging terms: https://docs.python.org/3/glossary.html

- module
- package
- sub-package
- distribution package
game-inventory 0.0.1
A simple game inventory manager
Requires Python: >=3.9

# Description
This package is used if you want a simple inventory for a text based game or just in general. This package is in development and in a testing stage.

# Basic Usage

```python
from game_inventory import Inventory
inventory = Inventory()
inventory.add_item("Your item")
print(inventory.get_inventory()) # Output: [Item(name: "Your item", amount: 1)]
```

# Functions


| Functions                                            | Description                                                  |
| ---------------------------------------------------- | ------------------------------------------------------------ |
| add_item(item: str, amount: int = 1) -> None         | Adds a item to the inventory                                 |
| remove_item(item_name: str, amount: int = 1) -> None | Removes a item in the inventory                              |
| get_item_at_index(index: int) -> str                 | Returns the item in the inventory at index                   |
| get_item_amount(item_name: str) -> int               | Returns the item amount at a index                           |
| get_inventory() -> list                              | returns list inventory                                       |
| where(item_name: str) -> int                         | returns the index of an item                                 |
| list_inventory() -> None                             | Prints all the items with a number that are in the inventory |
| display_inventory() -> None                          | Prints all the items in the inventory                        |
vfxtoolkit 0.0.1
Suite of tools for visual effects and media production.
Requires Python: >=3.8

# About This VFX Toolkit

This is a passion project which ultimately aims to provides a fully-featured
pipeline for visual effects and media production.

Planned features includes:
 - Cross-platform software packaging system (based on CMake, GIT & Python).
 - Production context system (commands and API to handle project & shot environments).
 - Layered configuration system.
 - QT-based application launcher.
 - VFX database model, object-oriented API and QT widgets.
 - QT-based media publisher (standalone then DCCs plugins).
 - Various helper libraries (Like media query & transcoder wrappers).

As of today however, it is merely a tiny set of in-progress rough libraries,
which are more of a pretext to get the git repo & pypi project going than
anything else. So if you're interested, please come back in a few months, by
then hopefully the project will have become something interesting :).
pytomography 3.4.0
Package to perform tomographic image reconstruction
Requires Python: >=3.9



# <img src="https://pytomography.readthedocs.io/en/latest/_static/PT1.png" alt= “” width="5%">  PyTomography    <img src="https://www.bccrc.ca/dept/io-programs/qurit/sites/qurit/files/FINAL_QURIT_PNG_60.png" alt= “” width="10%">

![Contributors](https://img.shields.io/github/contributors/qurit/PyTomography?style=plastic)
![Forks](https://img.shields.io/github/forks/qurit/PyTomography)
![Stars](https://img.shields.io/github/stars/qurit/PyTomography)
![Issues](https://img.shields.io/github/issues/qurit/PyTomography)

# Getting Started
We have prepared a very detailed documentation guide available at [readthedocs](https://pytomography.readthedocs.io/en/latest/). If you have any additional questions, please ask them on the [discourse website](https://pytomography.discourse.group/).

# Research Paper
If you use PyTomography in your own research, please cite the corresponding research paper:

**Lucas A. Polson, Roberto Fedrigo, Chenguang Li, Maziar Sabouri, Obed Dzikunu, Shadab Ahamed, Nicolas Karakatsanis, Sara Kurkowska, Peyman Sheikhzadeh, Pedro Esquinas, Arman Rahmim, and Carlos Uribe.** *PyTomography: A python library for medical image reconstruction.* SoftwareX, Volume 29, 2025, Page 102020. https://www.sciencedirect.com/science/article/pii/S235271102400390X

# License
This work is licensed under an MIT license, as is found in the LICENSE file.
bonk-mcp 0.1.11
A MCP server for Bonk
Requires Python: >=3.12

# bonk-mcp MCP server

The bonk-mcp server implements Solana blockchain functionality for the LetsBonk launchpad.


## Features
- Token launching: launch any token on letsbonk.fun
- Token trading: buy/sell any token on letsbonk.fun

## Configuration

The bonk-mcp server can be configured in Claude Desktop by adding it to the MCP servers configuration. You'll need to provide:
- Path to the bonk-mcp directory
- Environment variables:
  - `KEYPAIR`: Your Solana keypair
  - `RPC_URL`: Solana RPC endpoint (e.g., https://api.mainnet-beta.solana.com)

## Quickstart

### Install

#### Claude Desktop

On MacOS: `~/Library/Application\ Support/Claude/claude_desktop_config.json`
On Windows: `%APPDATA%/Claude/claude_desktop_config.json`

<details>
  <summary>Development/Unpublished Servers Configuration</summary>
  
  ```json
  "mcpServers": {
    "bonk-mcp": {
      "command": "uv",
      "args": [
        "--directory",
        "<PATH_TO_BONK_MCP_DIRECTORY>/bonk-mcp",
        "run",
        "bonk-mcp"
      ],
      "env": {
        "KEYPAIR": "<YOUR_SOLANA_KEYPAIR>",
        "RPC_URL": "https://api.mainnet-beta.solana.com"
      }
    }
  }
  ```
</details>

<details>
  <summary>Published Servers Configuration</summary>
  
  ```json
  "mcpServers": {
    "bonk-mcp": {
      "command": "uvx",
      "args": [
        "bonk-mcp"
      ],
      "env": {
        "KEYPAIR": "<YOUR_SOLANA_KEYPAIR>",
        "RPC_URL": "https://api.mainnet-beta.solana.com"
      }
    }
  }
  ```
</details>

## Development

### Building and Publishing

To prepare the package for distribution:

1. Sync dependencies and update lockfile:
```bash
uv sync
```

2. Build package distributions:
```bash
uv build
```

This will create source and wheel distributions in the `dist/` directory.

3. Publish to PyPI:
```bash
uv publish
```

Note: You'll need to set PyPI credentials via environment variables or command flags:
- Token: `--token` or `UV_PUBLISH_TOKEN`
- Or username/password: `--username`/`UV_PUBLISH_USERNAME` and `--password`/`UV_PUBLISH_PASSWORD`

### Debugging

Since MCP servers run over stdio, debugging can be challenging. For the best debugging
experience, we strongly recommend using the [MCP Inspector](https://github.com/modelcontextprotocol/inspector).

You can launch the MCP Inspector via [`npm`](https://docs.npmjs.com/downloading-and-installing-node-js-and-npm) with this command:

```bash
npx @modelcontextprotocol/inspector uv --directory <PATH_TO_BONK_MCP_DIRECTORY>/bonk-mcp run bonk-mcp
```

Upon launching, the Inspector will display a URL that you can access in your browser to begin debugging.

# Core contributor:
[0xwckd](https://github.com/0xwckd)