semvec/pypi-packages huggingface dataset:
fuzzyforest 0.1.0
Fuzzy forest-style feature ranking using repeated random forests.
License: MIT
Requires Python: >=3.9
Keywords: feature selection, random forest, machine learning, sklearn

# FuzzyForest

FuzzyForest is a small Python library that ranks features by stability using repeated random forests. It exposes:

- `FuzzyForestSelector`: a scikit-learn compatible transformer that averages feature importances across many resampled forests.
- `FuzzyForestRegressor`: a regressor that selects features with the selector, then fits a final random forest on the reduced feature set.

## Installation

```bash
pip install fuzzyforest
```

If you are developing locally, install in editable mode from the repo root:

```bash
pip install -e .
```

## Quickstart

```python
import numpy as np
from sklearn.datasets import fetch_california_housing
from fuzzyforest import FuzzyForestSelector, FuzzyForestRegressor

X, y = fetch_california_housing(return_X_y=True, as_frame=True)

# Rank and select the top 10 most stable features
selector = FuzzyForestSelector(top_k=10, n_resamples=30, random_state=42)
selector.fit(X, y)
print(selector.get_feature_ranking())        # ordered feature names
X_selected = selector.transform(X)           # reduced feature matrix

# End-to-end regression with built-in selection
model = FuzzyForestRegressor(top_k=10, random_state=42)
model.fit(X, y)
print(model.score(X, y))
```

## How it works

The selector builds `n_resamples` random forests, each on a bootstrap of the rows and a random subset of the columns. It averages the resulting feature importances, promoting features that are consistently useful across many draws. You can control:

- `sample_fraction` and `feature_fraction` to change how aggressive the perturbations are.
- `top_k` and `min_importance` to decide which features to keep.
- `task` (`"auto"`, `"classification"`, `"regression"`) to match the estimator.

## Publishing

This project is configured for `setuptools`. Once you are ready to publish to GitHub or PyPI:

1. Update `project.urls.Homepage` in `pyproject.toml` to the real repository URL.
2. Build the distribution:
   ```bash
   python -m pip install build
   python -m build
   ```
3. Upload to PyPI (optional):
   ```bash
   python -m pip install twine
   twine upload dist/*
   ```
macos-eye-care-plan 2025.12.21131932
A new package designed to help users maintain healthy eye habits while using macOS devices. The package takes user input describing their daily screen usage patterns, work environment, and any existin
License: MIT
Requires Python: >=3.9

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


A Python package that generates personalized 5-day eye care plans for macOS users based on their screen usage patterns and work habits.

## Installation

```bash
pip install macos_eye_care_plan
```

## Usage

```python
from macos_eye_care_plan import macos_eye_care_plan

# Provide information about your screen usage and environment
user_input = """
I work 8-10 hours daily on my MacBook Pro, mostly coding and writing.
My workspace has moderate lighting, and I experience occasional eye strain.
I take short breaks every hour but don't do any specific eye exercises.
"""

# Generate a personalized eye care plan
plan = macos_eye_care_plan(user_input=user_input)

# The plan returns a list of 5 daily schedules
for day, schedule in enumerate(plan, 1):
    print(f"Day {day}: {schedule}")
```

## Parameters

- `user_input` (str): Description of daily screen usage, work environment, and any eye discomfort
- `llm` (Optional[BaseChatModel]): LangChain LLM instance (defaults to ChatLLM7)
- `api_key` (Optional[str]): API key for LLM7 service

## Using Custom LLMs

You can use any LangChain-compatible LLM:

```python
from langchain_openai import ChatOpenAI
from macos_eye_care_plan import macos_eye_care_plan

llm = ChatOpenAI()
response = macos_eye_care_plan(user_input="Your input here", llm=llm)
```

```python
from langchain_anthropic import ChatAnthropic
from macos_eye_care_plan import macos_eye_care_plan

llm = ChatAnthropic()
response = macos_eye_care_plan(user_input="Your input here", llm=llm)
```

```python
from langchain_google_genai import ChatGoogleGenerativeAI
from macos_eye_care_plan import macos_eye_care_plan

llm = ChatGoogleGenerativeAI()
response = macos_eye_care_plan(user_input="Your input here", llm=llm)
```

## LLM7 Configuration

The package uses ChatLLM7 from [langchain_llm7](https://pypi.org/project/langchain-llm7/) by default. For higher rate limits:

```bash
export LLM7_API_KEY="your_api_key"
```

Or pass directly:
```python
response = macos_eye_care_plan(user_input="Your input", api_key="your_api_key")
```

Get a free API key at: https://token.llm7.io/

## Issues

Report issues at: https://github.com/chigwell/macos-eye-care-plan/issues

## Author

Eugene Evstafev (hi@euegne.plus)
permuted-brunnermunzel 0.1.0
Python implementation of the permuted Brunner-Munzel test for small sample sizes
License: MIT
Requires Python: >=3.8
Keywords: statistics, brunner-munzel, nonparametric, hypothesis-testing

# Permuted Brunner-Munzel Test

[![PyPI version](https://badge.fury.io/py/permuted_brunnermunzel.svg)](https://pypi.org/project/permuted_brunnermunzel/)
[![Tests](https://github.com/MatthewCorney/permuted_brunner_munzel/actions/workflows/tests.yml/badge.svg)](https://github.com/MatthewCorney/permuted_brunner_munzel/actions)
[![Python 3.8+](https://img.shields.io/badge/python-3.8+-blue.svg)](https://www.python.org/downloads/)

A Python implementation of the **permuted Brunner-Munzel test**, a nonparametric test for comparing two independent samples.

## When to Use

The permuted Brunner-Munzel test is best suited for:
- Small sample sizes (7-10 observations per group)
- When standard parametric assumptions don't hold
- Comparing distributions that may differ in shape, not just location

For larger samples (>10 per group), consider using `scipy.stats.brunnermunzel`.

## Installation

```bash
pip install permuted_brunnermunzel
```

## Quick Start

```python
from permuted_brunnermunzel import permuted_brunnermunzel

# Sample data
x = [0, 0, 0, 1, 1, 1, 0]
y = [30, 20, 19, 18, 15, 10]

# Run the test
estimate, pvalue = permuted_brunnermunzel(x, y, alternative="less")

print(f"Effect size estimate: {estimate:.4f}")
print(f"P-value: {pvalue:.6f}")
```

**Output:**
```
Effect size estimate: 0.8571
P-value: 0.000583
```

## Parameters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `x` | list | required | First sample observations |
| `y` | list | required | Second sample observations |
| `alternative` | str | `"two_sided"` | `"two_sided"`, `"greater"`, or `"less"` |
| `nan_policy` | str | `"propagate"` | `"propagate"`, `"raise"`, or `"omit"` |
| `est` | str | `"original"` | `"original"` or `"difference"` |
| `force` | bool | `False` | Force test even for large samples |

## Returns

| Value | Description |
|-------|-------------|
| `estimate` | Effect size: P(X < Y) + 0.5*P(X = Y) for `est="original"`, or P(X < Y) - P(X > Y) for `est="difference"` |
| `pvalue` | The p-value for the test |

## Interpreting Results

- **estimate = 0.5**: No difference between groups
- **estimate > 0.5**: Values in Y tend to be larger than X
- **estimate < 0.5**: Values in X tend to be larger than Y
- **pvalue < 0.05**: Statistically significant difference (at alpha=0.05)

## Dependencies

- numpy >=1.20
- scipy >=1.7

## References

This is a Python reimplementation of the R package [brunnermunzel](https://cran.r-project.org/web/packages/brunnermunzel/).

Brunner, E. and Munzel, U. (2000). *The nonparametric Behrens-Fisher problem: Asymptotic theory and a small-sample approximation.*

## License

MIT License - see [LICENSE](LICENSE) for details.
notifex 2025.12.21125243
A new package that helps developers extract and structure notification content from iOS and Android devices for use with ClaudeCode. The package takes raw notification text as input and returns a stan
License: MIT
Requires Python: >=3.9

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


notifex is a Python package designed to help developers extract and structure notification content from iOS and Android devices for use with ClaudeCode. The package takes raw notification text as input and returns a standardized, machine-readable format, making it easier to consistently process and analyze notifications across different platforms.

## Installation

```bash
pip install notifex
```

## Usage

### Basic Usage

```python
from notifex import notifex

# Example with default LLM (ChatLLM7)
response = notifex("New message from John: Are we still meeting tomorrow?")
print(response)
```

### Custom LLM

You can use any LLM that's compatible with LangChain by passing a custom LLM instance:

#### Using OpenAI

```python
from langchain_openai import ChatOpenAI
from notifex import notifex

llm = ChatOpenAI()
response = notifex("New message from John: Are we still meeting tomorrow?", llm=llm)
```

#### Using Anthropic

```python
from langchain_anthropic import ChatAnthropic
from notifex import notifex

llm = ChatAnthropic()
response = notifex("New message from John: Are we still meeting tomorrow?", llm=llm)
```

#### Using Google

```python
from langchain_google_genai import ChatGoogleGenerativeAI
from notifex import notifex

llm = ChatGoogleGenerativeAI()
response = notifex("New message from John: Are we still meeting tomorrow?", llm=llm)
```

### API Key Configuration

By default, notifex uses ChatLLM7 with its free tier. If you need higher rate limits, you can provide your own API key:

```python
# Via parameter
response = notifex("Your notification text", api_key="your_llm7_api_key")

# Via environment variable
import os
os.environ["LLM7_API_KEY"] = "your_llm7_api_key"
response = notifex("Your notification text")
```

You can get a free API key by registering at https://token.llm7.io/

## Parameters

- `user_input` (str): The notification text to process
- `llm` (Optional[BaseChatModel]): The LangChain LLM instance to use. If not provided, ChatLLM7 is used by default.
- `api_key` (Optional[str]): The API key for LLM7. If not provided, it checks the environment variable LLM7_API_KEY.

## Contributing

Found a bug or have a feature request? Please open an issue at [https://github.com/chigwell/notifex/issues](https://github.com/chigwell/notifex/issues).

## Author

Eugene Evstafev - hi@euegne.plus
budgetscribe 2025.12.21124349
A new package that analyzes user-provided text descriptions of their monthly expenses and income to generate a structured affordability assessment. It categorizes spending, identifies potential saving
License: MIT
Requires Python: >=3.9

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


A new package that analyzes user-provided text descriptions of their monthly expenses and income to generate a structured affordability assessment.

## Overview

This package categorizes spending, identifies potential savings areas, and returns a clear breakdown of financial health without requiring sensitive data like bank statements. It helps users understand their budget can be optimized in a private, non-intrusive way.

## Installation

```bash
pip install budgetscribe
```

## Usage

```python
from budgetscribe import budgetscribe

user_input = "I spend $500 on rent, $300 on groceries, and $200 on entertainment."
response = budgetscribe(user_input)
print(response)
```

## Parameters

* `user_input`: str : the user input text to process
* `llm`: Optional[BaseChatModel] : the langchain llm instance to use, if not provided the default `ChatLLM7` will be used.
* `api_key`: Optional[str] : the api key for `llm7`, if not provided the `LLM7_API_KEY` environment variable will be used.

## LLM Integration

This package uses `ChatLLM7` from `langchain_llm7` by default. However, developers can safely pass their own `llm` instance (based on `https://docs.langchain.com`) if they want to use another LLM.

For example, to use the `openai` LLM:

```python
from langchain_openai import ChatOpenAI
from budgetscribe import budgetscribe

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

or to use the `anthropic` LLM:

```python
from langchain_anthropic import ChatAnthropic
from budgetscribe import budgetscribe

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

or to use the `google` LLM:

```python
from langchain_google_genai import ChatGoogleGenerativeAI
from budgetscribe import budgetscribe

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

## LLM7 Rate Limits

The default rate limits for `LLM7` free tier are sufficient for most use cases of this package. However, if higher rate limits are needed, developers can pass their own `api_key` via environment variable `LLM7_API_KEY` or directly like `budgetscribe(user_input, api_key="their_api_key")`.

To get a free API key, visit `https://token.llm7.io/`.

## Documentation and Support

Issues and feature requests: https://github.com/chigwell/budgetscribe

Author: Eugene Evstafev (<hi@eugene.plus>)