semvec/pypi-packages huggingface dataset:
talem-ai-cli 0.1.3
Administrative tool for RAG apps
License: MIT
Requires Python: >=3.8

# Talem CLI Tool

This CLI tooling allows for the addition of more context to be used by Talem AI chatbot.

## Usage:

```bash
pip install talem-ai-cli
talemai
```
## Technologies used:

- Click (to build a beautiful CLI)
- PyPDF (to load and read the pdf documents)
- Request (to load online resources to lead. **beware of copyright**)
- Langchain (to convert the pdfs into vector embeddings)
- AstraDB (to store the new vector embeddings)
- Pyfiglet (to make a fashionable and large title greeting)
- Setuptools (allows to config project to be a module in pip)
- Github Actions (CI/CD pipeline whvih builds package and publishes it to Pip)
- Beautifulsoup (allows for web crawling)
- Cohere (vector embedding translation)

## Commit Guide:

- To publish your commit to Pip, use the prefix "Publish:" in your commit message. You should add this to a merge commit message to main branch. 
  
- You must update the verison of the package in `setup.py` when publishing to Pip. If you do not, the build command run by Github Actions will fail and the changes will not be pushed to the Pip registry. You will know this is the case if you get the following error:

![image](https://github.com/user-attachments/assets/5d6af954-c848-4647-8c47-6168e93462d8)
toomanyplugins 0.1.0
Python utilities for automatic stub generation, excruciating line-by-line logging, and dynamic plugin injection.
License: MIT
Requires Python: >=3.8
Keywords: logging, plugin, stub-generation, decorator

# toomanyplugins

**Python utilities for excruciating logging, dynamic plugins & stub generation.**

- **`excruciating_logger`** / **`@annoying_class`**  
  Trace and log every line of your methods (sync or async) when `self.verbose` is `True`.  
- **`plugin(...)` decorator**  
  Inject functions into existing classes at runtime, with optional overrides and nested decorators.  
- **`auto_stub`**  
  Auto-generate and update PEP-compliant `.pyi` stubs next to your classes.  
- **`TypeConverter`**  
  Async helper for converting objects ↔ types, absorbing attributes, merging annotations, and introspection.
hubspot-integration-server 0.1.1
A server for integrating with HubSpot using Flask and Celery
License: MIT
Requires Python: >=3.6

# HubSpot Integration Core

## Overview

The HubSpot Integration Core serves as the foundational framework for building modular, reusable integrations with HubSpot and potentially other platforms, such as `PlaceholderSyncTarget`. This core handles essential functionalities like OAuth authentication, database connectivity, and webhook processing, allowing specific integrations to focus on custom logic and business-specific requirements.

## Design Philosophy

- **Modularity**: The structure promotes separation of concerns, where core functionalities are encapsulated within this core, reducing redundancy across specific integrations.
- **Scalability**: By abstracting common logic to a core library, new integrations can be quickly developed and deployed.
- **Extensibility**: Designed to be extended for additional services or webhook handling, allowing developers to customize and build upon the existing core.

## Features

- **OAuth Authentication**: Simplifies handling authentication processes with HubSpot and stores tokens securely.
- **Database Management**: Uses SQLAlchemy for ORM, facilitating database interactions and migrations.
- **Webhook Handlers**: Provides base handlers for managing incoming requests from HubSpot, expandable for other services.

## Installation and Setup

1. **Clone the Repository**:
   ```bash
   git clone <core-repo-url>
   cd hubspot_integration_core
    ```

2. **Install Dependencies**:
    ```bash
    pip install -r requirements.txt
    ```

3. **Set Up Environment Variables**:

Define environment configurations in a .env file.

4. **Run Database Migrations**:

    ```
    python -m app.init_db
    ```

5. **Start the Application**:

Launch the application using Docker Compose:

    ```bash
    docker-compose up --build
    ```

## Usage Notes
This core is intended to be used in tandem with specific integrations that implement additional service-specific logic. Developers should structure their integration following a similar modular design, utilizing this core for widespread reusable components.
jesse-rust 1.0.1
High-performance Rust-based technical indicators for Jesse trading framework
License: MIT
Requires Python: >=3.10
Keywords: trading, technical-analysis, indicators, rust, performance

# Jesse Rust

High-performance Rust-based technical indicators for the Jesse trading framework.

## Overview

`jesse-rust` is a Python extension module written in Rust that provides blazing-fast implementations of technical indicators commonly used in algorithmic trading. This package is designed to work seamlessly with the [Jesse](https://jesse.trade) trading framework, offering significant performance improvements over pure Python implementations.

## Features

- **High Performance**: Written in Rust for maximum speed and efficiency
- **Memory Safe**: Leverages Rust's memory safety guarantees
- **Numpy Integration**: Seamless integration with NumPy arrays
- **Cross-Platform**: Pre-built wheels available for Windows, macOS, and Linux
- **Easy Integration**: Drop-in replacement for Python-based indicators

## Installation

Install from PyPI using pip:

```bash
pip install jesse-rust
```

## Requirements

- Python 3.10 or higher
- NumPy 1.26.4 or higher

## Usage

The package is typically imported and used within the Jesse framework:

```python
import jesse_rust

# The module provides various technical indicators
# that can be used directly in your trading strategies
```

## Performance

Rust implementations typically show 5-10x performance improvements over equivalent Python code, especially for computationally intensive indicators with large datasets.

## Building from Source

If you need to build from source:

### Prerequisites

- Rust toolchain (install from [rustup.rs](https://rustup.rs/))
- Python development headers
- Maturin build tool

### Build Steps

```bash
# Clone the repository
git clone https://github.com/jesse-ai/jesse-rust.git
cd jesse-rust

# Install maturin
pip install maturin

# Build the package
maturin develop --release

# Or build wheel
maturin build --release
```

## Development

For development builds:

```bash
maturin develop --release
```

## Contributing

This package is part of the Jesse trading framework. Please refer to the main [Jesse repository](https://github.com/jesse-ai/jesse) for contribution guidelines.

## License

This project is licensed under the MIT License - see the LICENSE file for details.

## Support

- Documentation: [docs.jesse.trade](https://docs.jesse.trade)
- Community: [Jesse Discord](https://jesse.trade/discord)
- Issues: [GitHub Issues](https://github.com/jesse-ai/jesse-rust/issues)

## Acknowledgments

Built with:
- [PyO3](https://pyo3.rs/) - Rust bindings for Python
- [Maturin](https://github.com/PyO3/maturin) - Build and publish Rust-based Python extensions
- [NumPy](https://numpy.org/) - Numerical computing in Python