semvec/pypi-packages huggingface dataset:
yuya-py 1.1.0
A LIB MAIS BRABA DE INTERFACE GRÁFICA! 🔥

Interface gráfica STYLE em Python, feita por uma criança que programa python (no caso eu).

VERSÃO ESTÁVEL 1.1.0 - MAIS BRABA AINDA! 🔥

Como usar:
from yuya_py import YuyaPy

Features:
- Interface STYLE
- Gradientes BRABO
- Animações SINISTRAS
kurumii-events 0.0.3.8
A Module containing a basic Event System
Requires Python: >=3.7

# Installation:

```bash
pip install kurumii_events
```

# Usage

```python
from kurumii_events import EventManager
# Create an EventManager instance
manager = EventManager()

# Register an event
manager.register_event("greet")

# Define a callback
def say_hello(name):
    print(f"Hello, {name}!")

# Subscribe the callback to the event
manager.subscribe("greet", say_hello)

# Emit the event
manager.emit("greet", name="Alice")  # Output: "Hello, Alice!"

# Unsubscribe the callback
manager.unsubscribe("greet", say_hello)

# Decorator usage
@manager.event("greet")
def another_greeting(name):
    print(f"Hi, {name}!")

# Emit the event again
manager.emit("greet", name="Bob")  # Output: "Hi, Bob!"

```
nimble-aws 0.1.1
Nimble-AWS is a Python library engineered for high-performance, asynchronous communication with AWS services. The library focuses on providing streamlined adapters that abstract the complexity of AWS operations, making it easier to integrate AWS into your applications.
Requires Python: <4.0,>=3.11

# Nimble-AWS

Nimble-AWS is a Python library designed to simplify and accelerate interactions with AWS services. It provides asynchronous adapters for efficient communication and includes middleware to streamline event handling and AWS Lambda integration. Whether you're working on a small project or building large-scale distributed systems, Nimble-AWS helps you focus on your application logic by abstracting the complexities of AWS.

## Features

- **Asynchronous Communication**: Execute AWS service operations asynchronously for high performance.
- **Simplified Abstractions**: Adapters that make interacting with AWS services intuitive and less error-prone.
- **Middleware Support**: Built-in middlewares for event-driven architectures and Lambda functions.
- **Optimized Performance**: Designed for minimal latency and high throughput.

## Installation

Install Nimble-AWS using pip:

```bash
pip install nimble-aws
```

## Example Usage

### S3 Adapter
The following example demonstrates how to use the S3 adapter to retrieve files from an S3 bucket asynchronously:

```python
from nimble_aws.adapter import S3


async def handler():
    region = "us-east-1"
    bucket = "example-bucket"
    paths = ["path/to/file1.json", "path/to/file2.json"]
    files = await S3().get_files(bucket=bucket, paths=paths, decode=True, region=region)
    print(files)


def lambda_handler():
    loop = asyncio.get_running_loop()
    loop.run_until_complete(handler())

```


## Environment Configuration

The library uses an `env` module to retrieve default configurations such as the AWS region. Ensure your AWS credentials and environment variables are properly configured before using Nimble-AWS.

## Contributing

We welcome contributions to Nimble-AWS! Please read our [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines on how to get started.

## License

Nimble-AWS is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.

## Feedback

If you encounter any issues or have suggestions, please open an issue on our [GitHub repository](https://github.com/Doki-Labs/nimble).
isimplify 1.2.3
simplifies word counting
Requires Python: <4.0,>=3.12

# Word Frequency and Sentiment Analysis Package

isimplify is a Python library for dealing with word frequency.

## Installation

Use the package manager [pip](https://pip.pypa.io/en/stable/) to install isimplify.

```bash
pip install isimplify
```
additional requirments
```
pip install gradio matplotlib PyPDF2

```


# overview
 This Python package allows you to analyze word frequencies from text or PDF files, visualize the results using bar plots, and perform sentiment analysis on the text. It includes functionalities to remove stop words, customize the list of stop words, and generate plots for the most frequent words.

The package also provides an interactive Gradio interface to upload PDFs, perform analysis, and view the results.

# using UI to interact and visualize the word freq
```python
import isimplify

isimplify.showWindow()

```
# Interactable window for word frequency analysis

![Screenshot 2024-12-06 at 11 36 07 PM](https://github.com/user-attachments/assets/782dc6cd-89f1-4832-9539-a800908429fb)



## Usage
# get word freq by reading pdf 

```python
import isimplify

word_freq = isimplify.getWord_freq_file_removingStopWords("example.pdf")
print(word_freq)

```
# get word freq by reading pdf (without removing stop words)

```python
import isimplify

text = "This is an example text to analyze."
word_freq = isimplify.getWord_freq_text_removing_StopWords(text)
print(word_freq)


```
# save the plot
```python
import isimplify

text = "This is an example text to analyze."
plot_path = isimplify.plot_top_n_words_text(text, top_n=5)
print(f"Plot saved at: {plot_path}")

```



## Contributing

Pull requests are welcome. For major changes, please open an issue first
to discuss what you would like to change.

Please make sure to update tests as appropriate.

## License

[MIT](https://choosealicense.com/licenses/mit/)
llm-tool-registry 0.1.1
Implements a tool registry to make tool calling easier when using LLMs
Requires Python: >=3.9

The llm_tool_registry package simplifies tool/function calling integration with Language Models (LLMs) like OpenAI's GPT models. It provides a clean, type-safe way to register Python functions as tools that can be called by LLMs.

Key features:
- Type-safe function registration with automatic JSON Schema generation
- Automatic parameter validation and documentation checking
- Support for OpenAI's function calling format
- Clean decorator-based API for registering tools
- Built-in docstring validation to ensure complete documentation
- Handles common Python types including strings, numbers, booleans, lists, and dictionaries
- Support for optional parameters and Union types

Example usage:

```python
from llm_tool_registry import ToolRegistry

registry = ToolRegistry()

@registry.tool()
def get_weather(location: str, unit: str = "celsius") -> dict:
    """Get the weather for a location.
    
    Args:
        location: The city and state/country
        unit: The temperature unit (celsius/fahrenheit)
    """
    # Implementation here
    pass

# Get OpenAI-compatible schema
schemas = registry.get_openai_schema()

# Execute registered tool
result = registry.execute("get_weather", location="London, UK")
warprouter 0.1.1
A Python library for managing Cloudflare WARP routing on Windows
Requires Python: >=3.6

# warprouter

A Python library for managing Cloudflare WARP routing on Windows.

## Installation

```bash
pip install warprouter
```

## Usage

```python
from warprouter import WARPRouter

# Create router instance
router = WARPRouter()

# Get list of processes
processes = router.get_user_processes()
print("Available processes:", processes)

# Exclude specific processes from WARP
router.exclude_process(1234)  # Replace with actual PID

# Or include processes in WARP
router.include_process(5678)  # Replace with actual PID

# Apply configuration
success, message = router.apply_configuration()
print(message)

# Check WARP status
status, message = router.get_warp_status()
print(message)

# Reset all settings
router.reset_configuration()
```

## Features

- Get list of user processes
- Exclude/include specific processes from WARP
- Save and load configurations
- Check WARP status
- Reset to defaults

## License

MIT License - see LICENSE file for details.
objexp 1.0.3
List the members in a Object[also Class or Module].
Requires Python: >=3.9
Keywords: dir, vars, debug

# objexp

a util for python beginner.

objexp is a util to check what members in a object or Class or module imported.


## Installation

You can install objexp from [PyPI](https://pypi.org/project/objexp/):

```bash
pip install objexp
```

Objexp is supported on Python 3.7 and above. 

## How to use

There is only 1 function: ox(), with 2 parameters, `savefile`, `ifprint`

savefile: "md", "json" or "both", the result str will be saved into "./objexp.md(.json)", defult value is `None`.

ifprint:　if you dont want to output result on screen, you could give a `false` value to `ifprint`, which defult value is `true`.


```python

from objexp import ox

ox(print,savefile:str,ifprint:bool)

```
It will output the members of function `print` on the screen as below:

```bash
_________________________

<class 'builtin_function_or_method'>

<built-in function print>
_________________________

<class 'NoneType'>
__text_signature__,

<class 'builtin_function_or_method'>
__dir__, __format__, __init_subclass__, __new__, __reduce__, __reduce_ex__, __sizeof__, __subclasshook__,

<class 'method-wrapper'>
__call__, __delattr__, __eq__, __ge__, __getattribute__, __gt__, __hash__, __init__, __le__, __lt__, __ne__, __repr__, __setattr__, __str__,

<class 'module'>
__self__,

<class 'str'>
__doc__, __module__, __name__, __qualname__,

<class 'type'>
__class__,

"\n_________________________\n\n<class 'builtin_function_or_method'>\n\n<built-in function print>\n_________________________\n\n<class 'NoneType'>\n__text_signature__, \n\n<class 'builtin_function_or_method'>\n__dir__, __format__, __init_subclass__, __new__, __reduce__, __reduce_ex__, __sizeof__, __subclasshook__, \n\n<class 'method-wrapper'>\n__call__, __delattr__, __eq__, __ge__, __getattribute__, __gt__, __hash__, __init__, __le__, __lt__, __ne__, __repr__, __setattr__, __str__, \n\n<class 'module'>\n__self__, \n\n<class 'str'>\n__doc__, __module__, __name__, __qualname__, \n\n<class 'type'>\n__class__, \n"

```