semvec/pypi-packages huggingface dataset:
market-data-source 0.3.0
High-performance financial data generation with Python bindings. Rust-powered market data simulation for Python data scientists and quantitative researchers.
Requires Python: >=3.8
Keywords: market-data, synthetic-data, financial-data, trading, backtesting, quantitative-finance, ohlc, tick-data

# Market Data Source (Python Interface)

[![PyPI](https://img.shields.io/pypi/v/market_data_source?color=blue&label=PyPI%20Version&logo=pypi&logoColor=white)](https://pypi.org/project/market_data_source/)
[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/market_data_source?color=blue&logo=python&logoColor=white)](https://pypi.org/project/market_data_source/)
[![PyPI - License](https://img.shields.io/pypi/l/market_data_source?color=blue&logo=opensourceinitiative&logoColor=white)](https://pypi.org/project/market_data_source/)
[![Build Status](https://img.shields.io/github/actions/workflow/status/destenson/market-data-source/ci.yml?branch=main&label=Build%20Status&logo=github&logoColor=white)](https://github.com/destenson/market-data-source/actions)

This directory contains the Python bindings for the Market Data Source library, enabling seamless integration of high-performance financial data generation into Python applications.
resistorendecode 0.1.2
Tool to decode or encode resistance color codes
Requires Python: >=3.13
Keywords: color codes, smd, electronic, E24

<img align="right" src=icons/resistor_decoder.png width=120px>

# ResistorEn​Decode

This is a code copy (not a fork) from https://github.com/VoxelCubes/ResistorDecoder.  
Its a copy because, there are some infrastructure changes made which may not be very compatible with the original code base.

[![License: GPL v3](https://img.shields.io/badge/License-GPL%20v3-blue.svg)](https://www.gnu.org/licenses/gpl-3.0)

This is a standalone Qt GUI tool for color bands on through-hole resistors and number codes on SMD parts.
It supports 3, 4, 5, and 6 band resistors, as well as standard SMD codes, including the EIA-96 standard.

| 3 or 4 Bands | 5 Bands |
|:------------:|:-------:|
|![4band](example_screenshots/4band.png)|![5band](example_screenshots/5band.png)|
| 6 Bands | SMD |
|![6band](example_screenshots/6band.png)|![smd](example_screenshots/smd.png)|

With this version you can also encode resistance values.

## Features
- Encode resistance values
- Decode the resistance and tolerance, as well as the Temperature Coefficient of Resistance (for 6 band resistors).
- Can parse SMD codes¹, including the EIA-96 standard.
- Respects your system's Qt theming.

## Dependencies
PySide6

```
pip install PySide6
```

## Installation


```
git clone https://github.com/AlfredoCubitos/ResistorEnDeCode
cd ResistorEnDecode
python src/main.py
```

## Notes
1. Tolerance values are only standardized for EIA-96 codes and codes with short underlines. Check the manufacturer's datasheet if the tolerance is critical for your application.
stealth-browser-controller 0.1.8
A stealthy browser automation tool with only screen and mouse
Requires Python: >=3.7

# Stealth Browser Controller 🕵️‍♂️

Feeling insecure using Selenium, playwright, puppeteer, etc? Let's make things simple.

A Python package for browser automation that mimics human-like behavior with natural mouse movements and realistic typing patterns without using any browser automation libraries.

## 🌟 Features

- Human-like mouse movements and clicks
- Natural typing patterns
- Image-based element detection
- Easy-to-use browser control

## 🚀 Installation

```bash
pip install stealth-browser-controller
```

## 🎮 Quick Start

```python
from stealth_browser_controller import StealthBrowserController

# Create a browser instance
browser = StealthBrowserController("google-chrome")
# browser = StealthBrowserController("path/to/your/browser/executable")

# Open a website
browser.open("https://www.google.com")

# Find an element by image and input text
search_input = browser.find_element_by_image("path/to/search_input.png")
if search_input:
    search_input.input_text("Hello, World!")

# Find an element by image and click it
search_button = browser.find_element_by_image("path/to/search_button.png")
if search_button:
    search_button.click()
# Close the browser
browser.close()
```

## 📚 Documentation

### Browser Class
The main class for controlling the browser. Supports:
- Opening URLs
- Finding elements by image
- Typing text
- Mouse movements
- Scrolling
- Key presses

### Element Class
Represents elements on the page. Supports:
- Clicking (single, double, right-click)
- Text input
- Visibility checking

## 🤝 Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

## 📝 License

This project is licensed under the MIT License - see the LICENSE file for details.
blaidd 0.1.0
Helper to color scatterplots with labels
Requires Python: >=3.11

# blaidd

blaidd is a helper to distribute the colors of labels in a 2D scatterplot.

Let's say you want to make a 2-dimensional scatterplot and you'd like every datapoint to be colored according to a cluster label, but you have plenty of labels and so you risk to end up having nearby clusters with similar colors and not being able to distinguish them.

blaidd helps by trying to solve an optimization proble which maximizes the difference of scale between nearby clusters, trying to improve the visual effect of your scatterplot.
taskinator 0.2.2
A Python CLI task management tool for software development projects. Heavily inspired by claude-task-master
Requires Python: >=3.9

# Taskinator

A Python CLI task management tool for software development projects, inspired by task-master.

## Features

- Task generation from PRD documents
- Task management with dependencies
- Task analysis and complexity assessment
- AI-powered task expansion and breakdown
- Dependency validation and management
- Beautiful CLI interface with rich formatting

## Installation

```bash
# Using Poetry
poetry install

# Using pip
pip install .
```

## Configuration

Create a `.env` file in your project root with the following variables:

```
ANTHROPIC_API_KEY=your_anthropic_api_key
MODEL=claude-3-7-sonnet
MAX_TOKENS=4000
TEMPERATURE=0.7
PERPLEXITY_API_KEY=your_perplexity_api_key  # Optional
PERPLEXITY_MODEL=sonar-pro  # Optional
DEBUG=false
LOG_LEVEL=info
DEFAULT_SUBTASKS=3
DEFAULT_PRIORITY=medium
PROJECT_NAME=Taskinator
```

## Usage

```bash
# Show help
taskinator --help

# List all tasks
taskinator list

# Show the next task to work on
taskinator next

# Add a new task
taskinator add-task --prompt="Implement user authentication"

# Set task status
taskinator set-status --id=1 --status=done

# Expand a task into subtasks
taskinator expand --id=1 --num=3
```

## License

This project is licensed under the MIT License - see the LICENSE file for details.
chat-console 0.5.95
A command-line interface for chatting with LLMs, storing chats and (future) rag interactions
Requires Python: >=3.7


# Chat CLI

A comprehensive command-line interface for chatting with various AI language models. This application allows you to interact with different LLM providers through an intuitive terminal-based interface.

## Features

- Interactive terminal UI with Textual library
- Support for multiple AI models:
  - OpenAI models (GPT-3.5, GPT-4)
  - OpenAI reasoning models (o1, o1-mini, o3, o3-mini, o4-mini)
  - Anthropic models (Claude 3 Opus, Sonnet, Haiku)
- Conversation history with search functionality
- Customizable response styles (concise, detailed, technical, friendly)
- Code syntax highlighting
- Markdown rendering

## Installation

1. Clone this repository:
   ```
   git clone https://github.com/yourusername/chat-cli.git
   cd chat-cli
   ```

2. Install the required dependencies:
   ```
   pip install -r requirements.txt
   ```

3. Set up your API keys:
   
   Create a `.env` file in the project root directory with your API keys:
   ```
   OPENAI_API_KEY=your_openai_api_key_here
   ANTHROPIC_API_KEY=your_anthropic_api_key_here
   ```

## Usage

Run the application:
```
chat-cli
```

### Testing Reasoning Models

To test the OpenAI reasoning models implementation, you can use the included test script:
```
./test_reasoning.py
```

This script will test both completion and streaming with the available reasoning models.

### About OpenAI Reasoning Models

OpenAI's reasoning models (o1, o3, o4-mini, etc.) are LLMs trained with reinforcement learning to perform reasoning. These models:

- Think before they answer, producing a long internal chain of thought
- Excel in complex problem solving, coding, scientific reasoning, and multi-step planning
- Use "reasoning tokens" to work through problems step by step before providing a response
- Support different reasoning effort levels (low, medium, high)

The implementation in this CLI supports both standard completions and streaming with these models.

### Keyboard Shortcuts

- `q` - Quit the application
- `n` - Start a new conversation
- `s` - Toggle sidebar
- `f` - Focus search box
- `Escape` - Cancel current generation
- `Ctrl+C` - Quit the application

### Configuration

The application creates a configuration file at `~/.chatcli/config.json` on first run. You can edit this file to:

- Change the default model
- Modify available models
- Add or edit response styles
- Change the theme
- Adjust other settings

## Data Storage

Conversation history is stored in a SQLite database at `~/.chatcli/chat_history.db`.

## Development

The application is structured as follows:

- `main.py` - Main application entry point
- `app/` - Application modules
  - `api/` - LLM provider API client implementations
  - `ui/` - User interface components
  - `config.py` - Configuration management
  - `database.py` - Database operations
  - `models.py` - Data models
  - `utils.py` - Utility functions

## License

MIT