semvec/pypi-packages huggingface dataset:
charming-traceback 0.1.9
Rich traceback adapted for PyCharm IDE by JetBrains
Requires Python: >=3.11

# 🐍 Charming Traceback

[Rich][rich] [traceback][rich_traceback] adapted for [PyCharm IDE by JetBrains][pycharm].

### Differences from the original

- File paths are rendered in the format which allows PyCharm to automatically detect them as links.
- `suppress` argument accepts string module names in addition to paths and Python modules already supported by Rich's `Traceback`. 

## Installation

Add to your project with `uv`:

```bash
uv add charming_traceback
```

## Usage

To install as the default traceback handler:

```python
from charming_traceback import install

install(show_locals=True)
```

To print the exception traceback manually:

```python
from charming_traceback import Traceback

try:
    do_something()
except Exception as e:
    Traceback.print_exception(show_locals=True)
```

Essentially, `Traceback` class is designed to be a drop-in replacement for `Traceback` from Rich. You can refer to the official [Rich traceback documentation][rich_traceback] for more usage info.

[rich]: https://github.com/Textualize/rich
[rich_traceback]: https://rich.readthedocs.io/en/stable/traceback.html
[pycharm]: https://www.jetbrains.com/pycharm/
procwatch 0.1.0
Process monitor CLI - list, filter, watch, and manage processes
Requires Python: >=3.8
Keywords: automation, cli, monitor, process, ps, top

# procwatch

Process monitor CLI - list, filter, watch, and manage processes.

## Installation

```bash
pip install procwatch
```

## Usage

### List Processes

```bash
# List top processes by CPU
procwatch list

# Sort by memory
procwatch list --sort mem

# Filter by name
procwatch list --filter python

# Filter by user
procwatch list --user root

# Show all (no limit)
procwatch list --all

# JSON output
procwatch list --json
```

### Watch a Process

```bash
# Watch a specific PID
procwatch watch 12345

# Custom interval
procwatch watch 12345 --interval 0.5

# Single snapshot as JSON
procwatch watch 12345 --json
```

### Process Tree

```bash
# Full process tree
procwatch tree

# Tree from specific PID
procwatch tree 12345

# JSON output
procwatch tree --json
```

### Live Monitor (like top)

```bash
# Live monitor
procwatch top

# Custom interval and limit
procwatch top --interval 1 --limit 20
```

### Kill Processes

```bash
# Kill by PID
procwatch kill 12345

# Kill by name pattern
procwatch kill python

# Force kill (SIGKILL)
procwatch kill python --force

# Skip confirmation
procwatch kill 12345 --yes

# JSON output (no prompts)
procwatch kill python --json
```

### Process Info

```bash
# Detailed info about a process
procwatch info 12345

# JSON output
procwatch info 12345 --json
```

## For AI Agents

See [SKILL.md](SKILL.md) for agent-optimized documentation.

## License

MIT
openstreetmap-mcp 1.0.1
A modular, enterprise-grade OpenStreetMap MCP server with advanced geospatial analytics.
Requires Python: >=3.10

# Enterprise OpenStreetMap (OSM) MCP Analytics Server

A modular, high-performance Model Context Protocol (MCP) server for OpenStreetMap. This implementation goes beyond simple geocoding, providing advanced geospatial analytics like neighborhood livability scoring and commute analysis.
## 🚀 Why this server?

While there are many OSM MCP servers, this version is built for **stability**, **modular extension**, and **advanced insights**:

- **Modular Architecture**: Clean separation between API Client, Utility logic, and Tool definitions. Easy to audit and extend.
- **Enterprise Analytics**:
  - `analyze_neighborhood`: Calculates a "Livability Score" based on walking proximity to essential services (groceries, healthcare, parks).
  - `analyze_commute`: Multi-modal comparison of travel times (car, bike, foot) for lifestyle planning.
- **Efficient**: Uses FastMCP for asynchronous I/O and structured tool registration.
- **Windows Optimized**: Built and tested to run reliably as a background process on Windows environments.

## 🛠 Features

### Core Tools
- **Geocoding**: `geocode_address`, `reverse_geocode`
- **Routing**: `get_route_directions` (OSRM based)
- **Search**: `find_nearby_places`, `search_category`
- **Analytics**: `explore_area`, `analyze_neighborhood`, `analyze_commute`

### Specialized Tools (Optional)
Found in `tools/extras.py` (not loaded by default for performance):
- `find_schools_nearby`
- `find_ev_charging_stations`
- `find_parking_facilities`
- `suggest_meeting_point`

### Resources
- `location://place/{query}`: Real-time place metadata.
- `location://map/{style}/{z}/{x}/{y}`: Interactive map tile retrieval.

## 📦 Installation

### Requirements
- Python 3.10+
- `uv` (recommended) or `pip`

### Method 1: Via MCP Config (Claude/Cursor)
Add this to your `mcp_config.json`:

```json
{
  "mcpServers": {
    "osm-mcp": {
      "command": "python",
      "args": [
        "c:/path/to/osm-mcp-server/src/openstreetmap_mcp/server.py"
      ],
      "env": {
        "PYTHONPATH": "c:/path/to/osm-mcp-server/src/openstreetmap_mcp"
      }
    }
  }
}
```

### Method 2: Local Development
```bash
git clone https://github.com/neco001/openstreetmap-mcp
cd openstreetmap-mcp
uv sync
```

## 📂 Project Structure

```text
src/openstreetmap_mcp/
├── server.py           # Main Entry Point
├── instance.py         # FastMCP lifecycle
├── client.py           # HTTP logic for OSM/OSRM/Overpass
├── utils.py            # Haversine & geometric helpers
├── tools/              # Categorized tool definitions
│   ├── geocoding.py
│   ├── routing.py
│   ├── search.py
│   └── analysis.py
└── resources.py        # Map & Data resources
```

## ⚖️ License

MIT License - feel free to use, modify and distribute.

## Acknowledgments

Original logic & concepts by [Jagan Shanmugam](https://github.com/jagan-shanmugam). This repository is a modular refactor focused on Enterprise usage, Windows compatibility, and Analytics tools.
deweypy 0.8.0
A Python client for Dewey Data (https://deweydata.io/).
Requires Python: <3.14,>=3.12

# deweypy

## Dewey Data Python Client

### Getting Started

To download your data using the Dewey Data Python Client, follow these steps in your command line or terminal:
1. **Install the client**

```bash
pip install deweypy
```

2. **Make a directory for your downloads**
```bash
mkdir dewey-downloads/
```

3. **Locate `FOLDER_ID`**

`FOLDER_ID` can be extracted from the end of the end of the API URL after `data/`

4. **Run client**
```bash
python -m deweypy --api-key <YOUR_API_KEY> speedy-download <FOLDER_ID>
```


#### A few notes...
- For now, please use the CLI to download data. This method is well tested; notebook support will be available soon.
- Increasing the number of workers for multi-threaded downloads yields diminishing returns, as API requests are limited both by our bucket’s rate limits and your own. We recommend the default of 8 workers, but you can override this with:
`--num-workers <INT>` following `speedy-download <FOLDER_ID>`.
- If your dataset is date-partitioned, you can limit the data processed by specifying partition boundaries at the end of your command:
```bash
--partition-key-before YYYY-MM-DD --partition-key-after YYYY-MM-DD
```
- `--partition-key-before` includes all partitions up to and including the given date.
- `--partition-key-after` includes all partitions from and including the given date onward.
### Working with data post-download
For guidance on analyzing your downloaded data, check out the [provided notebook tutorial](https://github.com/Dewey-Data/deweypy/blob/main/notebook-examples/customized-monthly-patterns.ipynb). It demonstrates how to work with Polars, Pandas, and DuckDB, and includes methods for exporting data to Parquet format for more efficient downstream analysis.