semvec/pypi-packages huggingface dataset:
make-selection 1.0.7
Package for interactive command line menu
Requires Python: >=3.9

<p align="center">
  <img src="https://github.com/steve3424/make_selection/blob/main/images/logo.png?raw=true" alt="Make selection logo">
</p>


## Setup
```
pip install make_selection
```

## Example
#### file.py
```python
from make_selection import makeSelection

options = ["one", "two", "three"]
label = "choose option"
selected = makeSelection(options, label)
```

#### Interacting with menu
<img src="https://github.com/steve3424/make_selection/blob/main/images/using_menu.png?raw=true" alt="image of cli while using the menu">
<br>

#### After making selection
<img src="https://github.com/steve3424/make_selection/blob/main/images/item_selected.png?raw=true" alt="image of cli after item is selected">
distributed-state-network 0.6.7
A tool to distribute the state of a network device to other devices on the network
Requires Python: >=3.10
Keywords: distributed, networking

# Distributed State Network

A Python framework for building distributed applications where nodes automatically share state without explicit data requests.

## Why DSN?

Traditional distributed systems require constant polling or complex pub/sub mechanisms to share state between nodes. DSN solves this by providing:

- **Automatic state synchronization** - Changes propagate instantly across the network
- **No single point of failure** - Every node maintains its own state
- **Simple key-value interface** - Read any node's data as easily as local variables
- **Complete Security** - Triple-layer encryption protects your network

Perfect for building distributed monitoring systems, IoT networks, or any application where multiple machines need to share state efficiently.

## Installation

```bash
pip install distributed-state-network
```

## Quick Start

### 1. Create Your First Node

The simplest DSN network is a single node:

```python
from distributed_state_network import DSNodeServer, DSNodeConfig

# Start a node
node = DSNodeServer.start(DSNodeConfig(
    node_id="my_first_node",
    port=8000,
    bootstrap_nodes=[]  # Empty for the first node
))

# Write some data
node.node.update_data("status", "online")
node.node.update_data("temperature", "72.5")
```

## How It Works

DSN creates a peer-to-peer network where each node maintains its own state database:

**Key concepts:**
- Each node owns its state and is the only one who can modify it
- State changes are automatically broadcast to all connected nodes
- Any node can read any other node's state instantly
- All communication is encrypted with AES

## Example: Distributed Temperature Monitoring

Create a network of temperature sensors that share readings:

```python
# On each Raspberry Pi with a sensor:
sensor_node = DSNodeServer.start(DSNodeConfig(
    node_id=f"sensor_{location}",
    port=8000,
    bootstrap_nodes=[{"address": "coordinator.local", "port": 8000}]
))

# Continuously update temperature
while True:
    temp = read_temperature_sensor()
    sensor_node.node.update_data("temperature", str(temp))
    sensor_node.node.update_data("timestamp", str(time.time()))
    time.sleep(60)
```

On the monitoring station:
```python
for node_id in monitor.node.peers():
    if node_id.startswith("sensor_"):
        temp = monitor.node.read_data(node_id, "temperature")
        print(f"{node_id}: {temp}°F")
```
  
### Documentation
* [Usage Examples](./documentation/usage.md)  
* [Configuration Class](./documentation/ds-node-config.md)
* [Server Class](./documentation/ds-node-server.md)
* [Protocol Class](./documentation/ds-node.md)
* [Protocol](./documentation/protocol.md)

#### API Reference
* [DSNodeServer](./documentation/ds-node-server.md)
* [DSNode](./documentation/ds-node.md)
* [DSNodeConfig](./documentation/ds-node-config.md)
dir2clip 0.1.3
A CLI tool to flatten directory contents to clipboard for LLM context.
Requires Python: >=3.6

# Dir2Clip

A command-line tool that recursively scans a directory, formats text files into a single string, and copies them to the clipboard. Useful for quickly pasting code context into LLMs.

## Features

- **Smart Scanning**: By default, scans only the current directory. Use `-r` for recursive scanning.
- **Filters** binary files and common ignores (e.g., `.git`, `venv`, `__pycache__`).
- **Formats** output with Markdown headers (`### FILE: path/to/file`) and code blocks.
- **Truncates** output (default: 100k chars) to prevent exceeding clipboard or context limits.
- **Cross-platform** clipboard support (Linux/macOS/Windows).

## Installation

Install via pip:

```bash
pip install dir2clip
```

*Note: Linux users may need `xclip` or `xsel` installed (`sudo apt install xclip`).*

## Usage

Run `dir2clip` in your terminal:

```bash
# Scan current directory (files only)
dir2clip

# Scan with recursion (include subdirectories)
dir2clip -r

# Scan specific path recursively
dir2clip ./src -r

# Set character limit (default: 100000)
dir2clip --max-len 50000
```

### Output Format

The tool copies content in this format:

```text
### FILE: src/main.py
```
import os
...
```

### FILE: README.md
```
# Documentation
...
```
```

## Configuration

To exclude additional directories, you can modify the `IGNORE_DIRS` set in the source code or file an issue to make it configurable via args.

## License

MIT