semvec/pypi-packages huggingface dataset:
Canoe-PY 0.1.1
A custom library for interacting with Vector CANoe
Requires Python: >=3.6

# Canoe_PY

A custom Python library for interacting with Vector CANoe.

## Installation

```bash
pip install Canoe_PY
```

## Features

- Connect to running CANoe instances
- Open and create CANoe configurations
- Start, stop, and reset measurements
- Get and set signal values
- Get and set system variables
- Get and set environment variables
- Compile and call CAPL functions
- Add and remove databases
- Comprehensive error handling and logging

## Usage

See the [examples](examples/) directory for detailed usage examples.

### Basic Usage

```python
from Canoe_PY import MyCANoe

# Create instance
canoe = MyCANoe()

# Connect to CANoe
canoe._connect_to_canoe()

# Open configuration
canoe.open_configuration("path/to/config.cfg")

# Start measurement
canoe.start_measurement()

# Work with system variables
canoe.set_system_variable_value("sys_var_demo::speed", 50)

# Stop measurement
canoe.stop_measurement()

# Quit CANoe
canoe.quit()
```

## Requirements

- Python 3.6 or higher
- pywin32
- Vector CANoe installed


## License

MIT
ip-to-country 1.0.2
Convert IP addresses to countries using delegated registry data
Requires Python: >=3.6

# ip-to-country

**ip-to-country** is a blazing-fast, offline Python library that determines the country for any given IP address (IPv4 or IPv6) using pre-parsed regional internet registry data.

No internet access or third-party APIs required: everything runs **locally and instantly**.

---

## ⚡ Features

- 🌍 **Offline IP Geolocation** – no network calls or external services
- ⚡ **Super Fast Lookup** – optimized with binary search for IPv4
- ✅ **Supports IPv4 and IPv6**
- 📦 **Uses Official RIR Data** – from AFRINIC, RIPE, ARIN, APNIC, and LACNIC
- 🌐 **Country Code + Name Output** – based on ISO 3166
- 🕵️ Supports special codes like `A1` (Anonymous Proxy), `A2`, `O1`, etc.


---

## 📦 Installation

```bash
pip install ip-to-country
```

## 🛠️ Usage

```python
from ip_to_country import IpToCountry

ip_lookup = IpToCountry()
country_info = ip_lookup.ip_to_country("8.8.8.8")

print(country_info)

# Output: {'country_code': 'US', 'ISO3166-1-Alpha-3': 'USA', 'region': 'Americas', 'continent': 'NA', 'languages': ['en-US', 'es-US', 'haw', 'fr'], 'country_name': 'United States of America', 'currency': 'US Dollar', 'currency_code': 'USD'}

```
efficient-context 0.1.0
Optimize LLM context handling in CPU-constrained environments
Requires Python: >=3.7
Keywords: llm, context, optimization, cpu, memory, efficiency, nlp

# efficient-context

A Python library for optimizing LLM context handling in CPU-constrained environments.

## Overview

`efficient-context` addresses the challenge of working with large language models (LLMs) on CPU-only and memory-limited systems by providing efficient context management strategies. The library focuses on:

- **Context Compression**: Reduce memory requirements while preserving information quality
- **Semantic Chunking**: Go beyond token-based approaches for more effective context management
- **Retrieval Optimization**: Minimize context size through intelligent retrieval strategies
- **Memory Management**: Handle large contexts on limited hardware resources

## Installation

```bash
pip install efficient-context
```

## Quick Start

```python
from efficient_context import ContextManager
from efficient_context.compression import SemanticDeduplicator
from efficient_context.chunking import SemanticChunker
from efficient_context.retrieval import CPUOptimizedRetriever

# Initialize a context manager with custom strategies
context_manager = ContextManager(
    compressor=SemanticDeduplicator(threshold=0.85),
    chunker=SemanticChunker(chunk_size=256),
    retriever=CPUOptimizedRetriever(embedding_model="lightweight")
)

# Add documents to your context
context_manager.add_documents(documents)

# Generate optimized context for a query
optimized_context = context_manager.generate_context(query="Tell me about the climate impact of renewable energy")

# Use the optimized context with your LLM
response = your_llm_model.generate(prompt=prompt, context=optimized_context)
```

## Features

### Context Compression
- Semantic deduplication to remove redundant information
- Importance-based pruning that keeps critical information
- Automatic summarization of less relevant sections

### Advanced Chunking
- Semantic chunking that preserves logical units
- Adaptive chunk sizing based on content complexity
- Chunk relationships mapping for coherent retrieval

### Retrieval Optimization
- Lightweight embedding models optimized for CPU
- Tiered retrieval strategies (local vs. remote)
- Query-aware context assembly

### Memory Management
- Progressive loading/unloading of context
- Streaming context processing
- Memory-aware caching strategies

## Maintainer

This project is maintained by [Biswanath Roul](https://github.com/biswanathroul)

## License

MIT