semvec/pypi-packages huggingface dataset:
text-geo-map 2025.12.21225445
text-geo-map turns plain text location descriptions into standardized geospatial data for interactive maps.
License: MIT
Requires Python: >=3.9

## Package Title
[![PyPI version](https://badge.fury.io/py/text-geo-map.svg)](https://badge.fury.io/py/text-geo-map)
[![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](https://opensource.org/licenses/MIT)
[![Downloads](https://static.pepy.tech/badge/text-geo-map)](https://pepy.tech/project/text-geo-map)
[![LinkedIn](https://img.shields.io/badge/LinkedIn-blue)](https://www.linkedin.com/in/eugene-evstafev-716669181/)

Transforming Text Descriptions to Structured Geospatial Data
================

#### About the Package

A new Python package that converts plain text descriptions of locations into structured geospatial data. The package extracts and validates key details such as coordinates, addresses, or landmarks from the text and outputs the information in a standardized format.

#### Installing
----------------

Install the package via pip:
```bash
pip install text_geo_map
```

#### Using the Package
--------------------

```python
from text_geo_map import text_geo_map

user_input = "The Eiffel Tower in Paris, France"
response = text_geo_map(user_input)
print(response)
```

#### Parameters
------------

The `text_geo_map` function accepts the following parameters:

- `user_input`: The text description of a location.
- `llm`: An instance of the LangChain `BaseChatModel` to use for LL7 queries (default is `ChatLLM7` from `langchain_llm7`).
- `api_key`: The API key for LLM7 (default is `None`, which will use the `LLM7_API_KEY` environment variable).

You can also pass your own instance of a LangChain chat model by using the `llm` parameter. For example:

```python
import os

from langchain OpenAI import ChatOpenAI
from text_geo_map import text_geo_map

llm = ChatOpenAI()
response = text_geo_map(user_input, llm=llm)
```

Example to use the Anthropics:

```python
import os

from langchain_anthropic import ChatAnthropic
from text_geo_map import text_geo_map

llm = ChatAnthropic()
response = text_geo_map(user_input, llm=llm)
```

Example to use the Google generative ai:

```python
import os

from langchain_google_genai import ChatGoogleGenerativeAI
from text_geo_map import text_geo_map

llm = ChatGoogleGenerativeAI()
response = text_geo_map(user_input, llm=llm)
```

Note: The default rate limits for LLM7 free tier should be sufficient for most use cases of this package. If you need higher rate limits, you can pass your own API key via the environment variable `LLM7_API_KEY` or directly as the `api_key` parameter.

You can obtain a free API key by registering on https://token.llm7.io/.

#### Documentation
-----------------

More information can be found on the GitHub repository at: https://github.com/chigwell/

#### Author
----------------

This package was created by Eugene Evstafev and can be reached at hi@euegne.plus.
llm-editor 0.1.5
A CLI tool to edit and chat with files using LLMs
License: MIT

# LLM Editor

A CLI tool to edit files using LLMs.

## Installation

```bash
pip install llm-editor
```
or, if you are installing from git directly
```bash
git@github.com:gptabhinav/llm-editor.git
pip install .
```

## Configuration

You can configure the tool using a YAML file.

### YAML Configuration

Run the following command to generate a default configuration file at `~/.llm-editor/config.yaml`:

```bash
edit --init-config
```

Then edit the file to add your API key:

```yaml
llm:
  provider: openai
  api_key: "your-api-key"
  model: "gpt-4o"

app:
  backup_enabled: true
  backup_suffix: ".backup"
```

## Usage

### 1. Using Prompt Tags (Scripting Mode)

Add your instructions directly to the file using `<tag>` markers.

**Example `input.txt`:**

```text
<tag> start_prompt
Convert the following Python code to JavaScript.
<tag> end_prompt

def greet(name):
    print(f"Hello, {name}!")

greet("World")
```

Run the tool:

```bash
edit input.txt
```

### 2. Interactive Mode

If the input file does not contain prompt tags, the tool will open your default text editor (configured via `$EDITOR`). You can type your instructions there, save, and close the editor to proceed.

![Interactive Mode Workflow](assets/sample_worflow1.gif)

### 3. Chat Mode

You can start an interactive chat session about your files using the `--chat` flag. This is useful for asking questions, getting explanations, or discussing potential changes without modifying the files directly.

**Single File:**
```bash
edit file.py --chat
```

**Multiple Files:**
You can pass multiple files to load them all into the chat context.
```bash
edit file1.py file2.py --chat
```

**Directories & Patterns:**
You can also pass directories or glob patterns to load multiple files at once.
```bash
# Load all files in a directory (recursive)
edit src/ --chat

# Load all Python files using glob pattern
# (Use quotes to ensure the tool handles the pattern matching)
edit "src/**/*.py" --chat
```

### Options

- `--outfile <path>`: Write output to a specific file (input file is preserved).
- `--inplace`: Overwrite the input file directly (skips backup).
- `--init-config`: Initialize the configuration file.
- `--chat`: Start an interactive chat session about the file(s).

## Usage Tracking & Costs

The tool automatically tracks token usage and estimates costs for each operation.

Logs are stored in `~/.llm-editor/logs/usage.log` and contain:
- Timestamp
- Model used
- Token counts (Input/Output/Total)
- Estimated cost (USD)

Example log entry:
```text
--- Usage Report (2023-10-27T10:00:00.123456) ---
Model: gpt-4o
Input Tokens:  150
Output Tokens: 50
Total Tokens:  200
Estimated Cost: $0.001250
------------------------------
```
wizlight-simple 0.1.2
Asynchrone Library für WiZ-Geräte mit RGB, Szenen und zirkadianem Rhythmus
License: MIT
Requires Python: >=3.8

Simple WiZ Control 💡Eine moderne, vollständig asynchrone Python-Library zur Steuerung von WiZ-Geräten (Steckdosen, Lampen, LED-Streifen). Diese Library wurde entwickelt, um eine leichtgewichtige und performante Alternative für Smart-Home-Enthusiasten zu bieten.FeaturesVollständig Asynchron: Basierend auf asyncio für maximale Performance ohne Blockierung des Haupt-Threads.Duale Discovery: Findet Geräte parallel über WiZ-UDP-Broadcast und Matter/mDNS (Zeroconf).Echtzeit-Status (Push): Empfängt sofortige Status-Updates von Geräten (z. B. bei manueller Schaltung), ohne Polling zu benötigen.Umfassende Steuerung:An/Aus & Dimmen (10-100%).RGB-Farbauswahl (0-255).Farbtemperatur (Kelvin).Über 30 vordefinierte Licht-Szenen.Zirkadianer Rhythmus: Aktivierung des biologischen Lichtmodus mit einem Befehl.Robustes Networking: Nutzt SO_REUSEADDR, um Port-Konflikte mit anderen WiZ-Apps zu minimieren.InstallationInstalliere die Library einfach via pip:pip install simple-wiz-control
SchnellstartHier ist ein einfaches Beispiel, wie du Geräte im Netzwerk findest und steuerst:import asyncio
from wiz_light import SimpleWizScanner, WizScene

async def main():
    # 1. Geräte suchen
    print("Suche Geräte...")
    devices = await SimpleWizScanner.discover(timeout=2.0)

    if not devices:
        print("Keine Geräte gefunden.")
        return

    # Das erste gefundene Gerät nehmen
    device = devices[0]
    print(f"Steuere Gerät: {device.ip}")

    # 2. Aktionen ausführen
    await device.turn_on()
    await device.set_brightness(50)
    await asyncio.sleep(2)

    # Auf eine Szene schalten
    await device.set_scene(WizScene.OCEAN)

    # Zurück zu Warmweiß
    await device.set_color_temp(2700)

if __name__ == "__main__":
    asyncio.run(main())
Echtzeit-Updates (Push-Listener)Anstatt den Status ständig abzufragen (Polling), kann diese Library auf "Push-Nachrichten" der Geräte lauschen. Das spart Netzwerkbandbreite und reagiert sofort.import asyncio
from wiz_light import start_push_listener

async def handle_update(ip, params):
    state = "AN" if params.get("state") else "AUS"
    power = params.get("power", 0) / 1000
    print(f"🔔 Update von {ip}: Status ist {state}, Verbrauch: {power}W")

async def run_listener():
    # Startet den Server auf Port 38899
    transport = await start_push_listener(handle_update)
    print("Lausche auf Live-Updates... (Strg+C zum Beenden)")

    try:
        await asyncio.Event().wait()
    except KeyboardInterrupt:
        transport.close()

if __name__ == "__main__":
    asyncio.run(run_listener())
Szenen-ÜbersichtVerwende das WizScene Enum für eine einfache Auswahl:WizScene.OCEANWizScene.ROMANCEWizScene.PARTYWizScene.FIREPLACEWizScene.COZYWizScene.FOREST... und viele mehr.LizenzDieses Projekt ist unter der MIT-Lizenz lizenziert – siehe die LICENSE Datei für Details.