semvec/pypi-packages huggingface dataset:
netupload 0.2.0
Simple upload server for local network file transfers.

# netupload

<br>
<a href="https://pypi.org/project/netupload/">
    <img src="https://img.shields.io/pypi/v/netupload" alt="PyPI - Version">
</a>
<a href="https://github.com/zpg6/netupload">
    <img src="https://img.shields.io/pypi/l/netupload" alt="PyPI - License">
</a>
<a href="https://github.com/zpg6/netupload">
    <img src="https://img.shields.io/badge/github-zpg6/netupload-black" alt="GitHub Repo">
</a>
<br><br>

Simple file upload server for when you need to send files around on your local network.
Sometimes you don't want to login to your email and don't have a USB so this can be a quick way to transfer files.

![How it works](https://github.com/zpg6/netupload/raw/main/docs/how_it_works.png)

![Webpage Screenshot](https://github.com/zpg6/netupload/raw/main/docs/cli_to_webpage.png)

## Usage

Install the package:

```
pip install netupload
```

Start the server with the default options:

```
netupload
```

## Options

```
netupload --host=0.0.0.0 --port=4000 --save-dir=./uploads
```

| Option     | Description                      | Default   |
| ---------- | -------------------------------- | --------- |
| --host     | Host to run the server on        | 0.0.0.0   |
| --port     | Port to run the server on        | 4000      |
| --save-dir | Directory to save uploaded files | ./uploads |

## Webpage

The server runs a webpage that you can access from any device on the same network.
You will see the

```
> netupload --host=0.0.0.0 --port=4000 --save-dir=./uploads

 * Serving Flask app 'src.app'
 * Debug mode: off
 * Running on all addresses (0.0.0.0)
 * Running on http://127.0.0.1:4000
 * Running on http://192.168.1.123:4000 <--------- THIS ADDRESS WITH YOUR COMPUTER'S LOCAL IP
```

Navigate to the address shown in the terminal to access the webpage.
py-wordsearch-gen 2025.7.2
Command line tool to generate fun to play word searches.
Requires Python: >=3.12

# py-wordsearch-gen - Word Search Generator

[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
[![Tests](https://github.com/brass75/wordsearch/actions/workflows/test.yml/badge.svg)](https://github.com/brass75/wordsearch/actions/workflows/test.yml)
[![Mastodon Follow](https://img.shields.io/mastodon/follow/109552736199041636?domain=https%3A%2F%2Ftwit.social&style=flat)](https://twit.social/@brass75)

py-wordsearch-gen is a word search generator, originally written to generate a word search for distribution at the PSF booth
at PyCon US 2025. It is incredibly simple to use and will generate a new word search with every run.

## Installation

Installation is easy:
```shell
pip install py-wordsearch-gen
```

# Usage

To use just run `wordsearch` from the command line.

```shell
usage: wordsearch.py [-h] [-w [WIDTH]] [-t [HEIGHT]] [-m [MIN_WORD]] [-d] [-r] [-k] [-x [EXCLUDED_LETTERS]] words [words ...]

Word Search Generator

positional arguments:
  words                 List of words for the search.

options:
  -h, --help            show this help message and exit
  -w, --width [WIDTH]   Width of puzzle, (Default: 10)
  -t, --height [HEIGHT]
                        Height of puzzle, If not set will be the same as the width (square puzzle.)
  -m, --min [MIN_WORD]  The minimum word length. Cannot be larger than the size of the grid. (Default: 4)
  -d, --diagonal        Allow words to be placed diagonally.
  -r, --reverse         Allow words to be placed backwards.
  -k, --answer-key      Print the answer key ahead of the puzzle.
  -x, --exclude [EXCLUDED_LETTERS]
                        A list of letters to be excluded as fill. Defaults to 'JQXZ'
```
create-lillie 12.0.1
A CLI tool for creating lilliepy projects
Requires Python: >=3.7
Keywords: reactpy, lilliepy, create-lillie, create-lilliepy

# create-lillie

## Usage:

```bash
create-lillie YOUR_PROJECT_NAME --is-empty
```
* create-lillie - cli name
* YOUR_PROJECT_NAME - name for your project
* --is-empty - if used, will generate empty project, if not, will generate starter project

## Requirements:
* git
* pip
* python
* nodejs
lilliepy 17.0.1
A Bundle of Pkgs for Lilliepy
Requires Python: >=3.7

this package contains all the imports for the following package-

lilliepy-dir-router  
lilliepy-bling  
lilliepy-head  
lilliepy-statics  
lilliepy-query  
lilliepy-state  
lilliepy-import
lilliepy-socket
lilliepy-build
lilliepy-protect
lillie-start
lilliepy-rebound
reactpy
reactpy-router
reactpy-utils
reactpy-forms
reactpy-table
reactpy-select
reactpy-apexcharts
pytailwindcss
flask_sock
markdown
hquery
lilliepy-tags
moviecli 0.1.2
CLI tool for searching and downloading movies from yts
Requires Python: >=3.8

# YTS Movie Torrent CLI
        
        A command-line interface (CLI) tool to search and download movie torrents from YTS.mx using a guided, interactive terminal experience. It allows you to:
        
        - Search for movies by name
        - View detailed information including IMDb, Audience Score, and more
        - Choose torrent quality and start downloads
        - Control the torrent download process (pause, resume, stop)
        
        ## Features
        
        - Interactive movie search using [InquirerPy](https://github.com/kazhala/InquirerPy)
        - Torrent download and progress tracking with `torrentp`
        - Integration with YTS movie database
        
        ## Installation
        
        ```bash
        pip install .
        ````
        
        ## Usage
        
        ```bash
        python -m moviecli "The Matrix"
        ```
        
        You will be prompted to:
        
        * Choose the correct movie
        * Select the desired torrent quality
        * Control the download with actions like pause, resume, stop
        
        ## Requirements
        
        * Python 3.8+
        * Dependencies listed in `setup.py`
        
        ## Dependencies
        
        * `click`
        * `InquirerPy`
        * `torrentp`
        * `beautifulsoup4`
        * `requests`
        
        ## License
        
        MIT License
        
        ````
mseep-plamo-translate 1.0.4
A command-line interface for translation using the plamo-2-translate model with local execution.
Requires Python: >=3.6
Keywords: mseep, machine translation, transformer, nlp, natural language processing, deep learning, mlx, mlx-lm, sentencepiece, plamo, plamo-translate, plamo-translate-cli

Package managed by MseeP.ai
mokei 0.2.18
A simple asynchronous Python web framework built on aiohttp.
Requires Python: >=3.10

# Mokei

Mokei is a simple asynchronous Python web framework built on aiohttp.

Aiohttp contains a great async web server, with web framework built in,
but can be complex when compared to other web frameworks.

Mokei makes setting up your routes as simple as using Flask or FastAPI.
It also includes super easy websocket routes with support for text and binary messages,
as well as SocketIO-style event handlers.

## Quick Start

    from mokei import Mokei
    
    app = Mokei()
    
    @app.get('/')
    async def hello():
        return 'Hello, World!'

    if __name__ == '__main__':
        app.run()

## Return JSON data

When the return type from the handler is a `dict`, the response is automatically converted to `application/json`

    @app.get('/status')
    async def status():
        return {
            'status': 'OK',
        }

## Adding Websocket support

Adding a websocket route is as simple as adding a normal get route.

Note that you may send websocket messages to a route or to a single websocket
(compare websocket.send_text and data.send_text below)

    app = Mokei()
    data = app.websocketroute('/data')
    
    @data.onconnect
    async def send_welcome_text(websocket):
        await websocket.send_text('Welcome!')

    @data.ontext
    async def relay_text(websocket, text):
        # log incoming text and relay to all other websockets
        logger.info('Received text %s', text)
        await data.send_text(text, exclude=websocket)

SocketIO-style events are also supported. See `js/mokei.js` for a Javascript handler for Mokei WebSockets.

    app = Mokei()
    data = app.websocketroute('/data')
    
    @data.on('ping')
    async def send_pong(websocket, data):
        update_something(websocket)
        await websocket.send_event('pong', {'timestamp': time.time()})
container-runtime-interface-api 2.0.1
Python library for interaction with the Kubernetes container runtime interface API.
Requires Python: >=3.10

## container-runtime-interface-api

Python library for communication with the Kubernetes [Container Runtime Interface API](https://github.com/kubernetes/cri-api).

### Usage

Install `container-runtime-interface-api` with `pipenv` or `pip`:

```shell
$ pipenv install container-runtime-interface-api
Adding container-runtime-interface-api to Pipfile's [packages]…
✔ Installation Succeeded
...
```

This project currently supports Python 3.10+.

#### Connection

Connection to the CRI API is generally done through a UNIX socket, but any gRPC address supported by [insecure_channel](https://grpc.github.io/grpc/python/grpc.html#grpc.insecure_channel) will work.

```python
from cri_api.channel import Channel
channel = Channel.from_env() # Loads from RUNTIME_SOCK
channel = Channel("unix:///var/run/dockershim.sock") # Explicit argument
```

#### Images

The `Images` class is a thin wrapper around the existing ImageService API:

```python
from cri_api.images import Images

channel = Channel.from_env()
images = Images(channel)

images.list_images()
images.pull_image("busybox")

busybox_images = [i["id"] for i in images.list_images() if any("busybox" in r for r in i["repoTags"])]
[images.remove_image(i) for i in busybox_images]
```

#### Containers

The `Containers` class is a thin wrapper around the existing RuntimeService API:

```python
from cri_api.images import Images
from cri_api import ContainerFilter, ContainerState, ContainerStateValue

channel = Channel.from_env()
images = Containers(channel)

containers.list_containers()
containers.list_containers(ContainerFilter(state=ContainerStateValue(state=ContainerState.CONTAINER_EXITED)))

containers.get_container("9d81052cc027a1fb2ec61b898ea0fd6fc88216ce730ad75f4c52b29849cb440f")
```

#### Raw

Raw access to the underlying CRI API objects can be done by importing from `cri_api`:

```python
from os import getenv
from grpc import insecure_channel
from cri_api import RuntimeServiceStub, ListContainersRequest

stub = RuntimeServiceStub(insecure_channel(getenv("RUNTIME_SOCK")))
response = stub.ListContainers(ListContainersRequest())
containers = response.containers
```

### Updating Protobuf Python Generated Code

```shell
$ bin/update-proto.sh
```

Commit & create a new pull request!

### Development

Interactive development on MacOS can be done by leveraging [minikube](https://kubernetes.io/docs/tasks/tools/install-minikube/):

```shell
$ minikube start --container-runtime=cri-o
$ minikube ssh
$ socat -d -d TCP4-LISTEN:15432,fork UNIX-CONNECT:/var/run/crio/crio.sock

# In another window, you can now connect on $(minikube ip):15432
$ export RUNTIME_SOCK=$(minikube ip):15432
...
```

### Testing

Unit tests are run against all supported Python versions: 3.10, 3.11, and 3.12.

A basic set of integration tests is included alongside the unit tests, but are only run if the `RUNTIME_SOCK` environment variable is set correctly.
They are verified in CI against a minikube installation running Docker and `dockershim`.

Run unit tests with:

```shell
$ pytest
```