semvec/pypi-packages huggingface dataset:
recommend-py 0.1.6
A library to do recommendations based on matrix
Requires Python: >=3.6

# Recommend_py
        
        this is a library to do recommendations based on matrix
        
        ## Functions
        - Function 1: is_utility(df) input the matrix and return if it is a utility matrix
        - Function 2: to_utility(df, id_col_num) input the matrix and the column number of the id and return the utility matrix
        - Function 3: utility_normalize(df) input the utility matrix and return the normalized utility matrix
        - Function 4: utility_standardize(df) input the utility matrix and return the standardized utility matrix
        - Function 5: similarity_calculation(df, mean_same_item) input the utility matrix and the minimum number of same items and return the similarity matrix
        - Function 6: recommend_calculation(df, top_n, mean_score) input the utility matrix, the number of top items to recommend and the minimum score a similar user must give for an item to be recommended and return the recommendation matrix
        
        ## Installation
        To install this project, clone the repository and install the required packages:
        ```
        pip install pandas
        pip install numpy
        pip install scikit-learn
        ```
        
        ## Usage
        To use this project, import the library and call the functions:
        ```
        import recommend_py
        
        recommend_py.is_utility(df)
        recommend_py.to_utility(df, id_col_num)
        recommend_py.utility_normalize(df)
        recommend_py.utility_standardize(df)
        recommend_py.similarity_calculation(df, mean_same_item)
        recommend_py.recommend_calculation(df, top_n, mean_score)
        ```
llmschema 0.3
A structured response wrapper for LLMs using Pydantic.
Requires Python: >=3.7

# llmschema

[![PyPI](https://img.shields.io/pypi/v/llmschema)](https://pypi.org/project/llmschema/)

`llmschema` is a Python library that ensures structured and validated responses from LLMs (Large Language Models) like Ollama, OpenAI, and Gemini by enforcing user-defined **Pydantic schemas**. It abstracts model-specific quirks and guarantees responses in a **safe, predictable, and JSON-compliant format**.

## 🚀 Features

✅ **Enforces Pydantic schema** on LLM responses  
✅ **Works with multiple LLM providers** (Ollama, OpenAI, Gemini, etc.)  
✅ **Handles malformed JSON responses gracefully**  
✅ **Easy integration** into existing applications  
✅ **Modular & scalable design**

---

## 📦 Installation

Install `llmschema` via pip:

```sh
pip install llmschema
```

---

## 🛠 Usage

### **1️⃣ Define a Schema**
```python
from pydantic import BaseModel
from llmschema import SchemaManager, generate_response

class MyResponseSchema(BaseModel):
    text: str
    confidence: float

SchemaManager.set_schema(MyResponseSchema)
```

### **2️⃣ Generate a Response from an LLM**
```python
response = generate_response("mistral", "Summarize the latest AI news")
print(response)  # Output will follow MyResponseSchema format
```

### **3️⃣ Handling Errors**
```python
from llmschema import LLMValidationError

try:
    response = generate_response("gemini", "Give me a JSON response")
except LLMValidationError as e:
    print("Invalid response:", e)
```

---

## ⚙️ Supported LLMs
`llmschema` is designed to work with different LLM providers:
- ✅ **Ollama** (Mistral, Llama, etc.)
- ✅ **OpenAI** (GPT models)
- ✅ **Gemini** (Google's LLM)

More integrations coming soon!

---

## ✅ Handling Non-JSON Responses
If an LLM outputs **invalid JSON**, `llmschema` will:
1. **Try to extract JSON** using regex.
2. **Log warnings** for malformed responses.
3. **Raise an error** if parsing fails completely.

---

## 🧪 Running Tests
To test the library locally:
```sh
pytest tests/
```

---

## 📜 License
This project is licensed under the **MIT License**.

---

## 🤝 Contributing
Contributions are welcome! Feel free to submit issues and PRs on GitHub.

GitHub Repo: [https://github.com/yourusername/llmschema](https://github.com/yourusername/llmschema)
xcryptowatch 0.1.2
A program to monitor crypto trends on social media.
Requires Python: >=3.6

# XCryptoWatch

XCryptoWatch is a powerful Python tool that monitors social media platforms (Twitter, Truth Social, and Bluesky) for cryptocurrency-related posts from specified accounts. It uses OpenAI's GPT to analyze posts and can notify users via email when relevant cryptocurrency content is detected.

## Features

- Multi-platform social media monitoring:
  - Twitter
  - Truth Social
  - Bluesky
- AI-powered post analysis using OpenAI's GPT
- Flexible notification system:
  - Postal API support
  - SMTP email support
- Configurable monitoring intervals
- Interactive command-line interface
- Comprehensive logging system

## Installation

To install XCryptoWatch, simply run:

```bash
pip install xcryptowatch
```

## Requirements

- Python 3.9 or higher
- Required packages (automatically installed):
  - postalsend
  - jsonschema
  - tweepy
  - openai
  - truthbrush
  - atproto

## Configuration

XCryptoWatch requires a configuration file (`config.json`) with your API credentials and settings. On first run, the program will guide you through creating this configuration.

Required credentials:
- Twitter API credentials (optional)
- Truth Social credentials (optional)
- Bluesky credentials (optional)
- OpenAI API key
- Email settings (SMTP or Postal)

## Usage

1. Start XCryptoWatch:

```bash
xcryptowatch
```

2. Use the interactive menu to:
- Start/stop watching different platforms
- Add new accounts to monitor
- Add notification recipients
- Configure API credentials and settings

## Menu Options

1. Start watching tweets
2. Stop watching tweets
3. Start watching truths
4. Stop watching truths
5. Start watching bluesky
6. Stop watching bluesky
7. Add a new account to watch
8. Add a new recipient to notify
9. Configure XCryptoWatch

## Configuration Options

The configuration interface allows you to set:
- Social media API credentials
- Monitoring intervals
- Email notification settings
- OpenAI API key

## Development

```bash
git clone https://github.com/steelproxy/xcryptowatch.git
cd xcryptowatch
pip install -e .
```

## License

MIT License - see LICENSE file for details.

## Author

Collin Rodes (steelproxy@protonmail.com)

## Version

Current version: 0.1.1

## Contributing

1. Fork the repository
2. Create your feature branch
3. Commit your changes
4. Push to the branch
5. Create a new Pull Request

## Security Note

Keep your `config.json` file secure as it contains sensitive API credentials. The file is automatically added to `.gitignore` to prevent accidental commits.
recopy 0.1.1
A library to do recommendations based on matrix
Requires Python: >=3.6

# Recopy
        
        ## Description
        this is a library to do recommendations based on matrix
        
        ## Functions
        - Function 1: is_utility(df) input the matrix and return if it is a utility matrix
        - Function 2: to_utility(df, id_col_num) input the matrix and the column number of the id and return the utility matrix
        - Function 3: utility_normalize(df) input the utility matrix and return the normalized utility matrix
        - Function 4: utility_standardize(df) input the utility matrix and return the standardized utility matrix
        - Function 5: similarity_calculation(df, mean_same_item) input the utility matrix and the minimum number of same items and return the similarity matrix
        - Function 6: recommend_calculation(df, top_n, mean_score) input the utility matrix, the number of top items to recommend and the minimum score a similar user must give for an item to be recommended and return the recommendation matrix
        
        ## Installation
        To install this project, clone the repository and install the required packages:
        ```
        pip install pandas
        pip install numpy
        pip install scikit-learn
        ```
        
        ## Usage
        To use this project, import the library and call the functions:
        ```
        import pyrecommend
        
        recopy.is_utility(df)
        recopy.to_utility(df, id_col_num)
        recopy.utility_normalize(df)
        recopy.utility_standardize(df)
        recopy.similarity_calculation(df, mean_same_item)
        recopy.recommend_calculation(df, top_n, mean_score)
        ```
easyuse-nacos 0.0.3.1
A user-friendly wrapper around the nacos-sdk-python package
Requires Python: >=3.8

# easyuse-nacos

easyuse-nacos is a user-friendly wrapper around the [nacos-sdk-python](https://github.com/nacos-group/nacos-sdk-python) package. please visit [homepage](https://zhangxiaojiawow.github.io/easyuse_nacos/) for more deatils.