semvec/pypi-packages huggingface dataset:
hubspot-api 0.7.0
Python library to interact with HubSpot's Private API
Requires Python: >=3.6

# HubSpot Private API

## Python library to interact with HubSpot's Private API

This is a Python library of HubSpot's Private API, which was reverse-engineered from their Mobile App. It allows users to do any kind of LLM automation / auto-reply (to live chats).

It was developed because **HubSpot doesn't bother making their Public API feature-complete**, and have had some modules in BETA for over a year (khm.. [Conversations](https://developers.hubspot.com/docs/api/conversations/conversations)).

**Additional features**, which their Public API doesn't support:

- Conversation: access Live Chat channels
- Conversation: Assign the conversation to an agent
- Conversation: Tag an agent inside a comment

## Demo script

```python
from hubspot_api import HubSpotApi

def cb_auth() -> str: # In case of 2FA, you'll need to return the code
    code = input('Enter 2FA code: ')
    return code

hs = HubSpotApi('my-email@provider.com', 'superSecretPw', cb_auth)

# You can also do hs.conversations.get_threads() to get all threads
threads = hs.conversations.get_unassigned_threads()
# Needed for assigning threads to agents
agents = hs.conversations.get_agents()

for t in threads:
    print('---------\nSubject:',t.subject, t.timestamp)
    msgs = t.read_messages()
    email_msgs = [f"FROM: {msg.fromName}, AT: {msg.timestamp}, EMAIL TEXT:\n{msg.text}" for msg in msgs]
    full_conversation = f'EMAIL SUBJECT: {t.subject}\n' + '\n\n'.join(email_msgs).lower()

    # Do some smart LLM stuff here

    if "api" in full_conversation or "code" in full_conversation:
        t.assign(agents.find('John Doe')) # Tech support
    elif "shipping" in full_conversation:
        t.assign(agents.find('Erik The Red')) # Ops/shipping
    elif "digital agency" in full_conversation:
        # They are trying to sell us something
        t.send_message("Thank you for your email, but we are not interested.")
        t.close()
    elif "tiktok" in full_conversation:
        t.spam() # TikTok? Spam for sure
    else:
        # Writing a comment (and tagging an agent) is also supported
        agent = agents.find('John Doe')
        t.comment(f'Hi {agent}, could you assign this to the best person?')
```

## Module support

While HubSpot has many different modules (contacts, deals, tickets, etc.), most of them work as expected
with their [public API](). Only Conversations are in "BETA", and have been for over a year now.

## Installation

To install this Python package, run the following command:

```bash
pip install hubspot-api
```

### Liability

**Note:** This unofficial API library is not endorsed by HubSpot and likely violates their Terms of Service. Use it at your own risk; the creator assumes no liability for any consequences.
agridable 0.0.4
AGridable is a Python library which makes formatting tables in your Dash app a breeze.
Requires Python: >=3.12


**AGridable** is a Python library which makes formatting tables in your Dash 
app a breeze 💨

It's a wrapper for the wonderful [Dash AG Grid](https://github.com/plotly/dash-ag-grid) 
library and enables users to quickly and easily apply formatting, without having to go through the (sometimes rather complex) process of configuration. 

For example, you can quickly and easily apply conditional colour formatting based on the range of values in a column.

The project was created by [James Laidler](https://github.com/lamesjaidler) 
whilst working at [Electrify Video Partners](https://electrify.video/).
pyproject-requirements 20240601
Install dependencies from a pyproject using pip.
Requires Python: >=3.6

# pip-requirements (aka pyproject-requirements)

Install requirements/dependencies specified in a pyproject.toml using pip.

## Features

- Installs required, optional and/or all dependencies.
- Detects and works with pip in installed in virtual environments.
- Generates a requirements.txt file from a pyproject.toml (for tool compatibility).

## Quick Start

1. Install pip-requirements:

   ```shell
   pip install pyproject-requirements
   ```

2. Install all dependencies of your pyproject.toml 

   ```shell
   # use `--optional name` to limit to optional named dependency section
   # use `--required` to install required dependencies
   pip-requirements install --all path/to/pyproject.toml 
   ```

## Why

- This only exists because it's not builtin to pip.

- Using requirements.txt files is primitive and redundant compared to the expressiveness
  of pyproject.toml files..


## Usage

```
pip-requirements [-h] {install,txt} ...

Install dependencies from a pyproject file.

optional arguments:
-h, --help     show this help message and exit

commands:
Valid commands

```

### `install` Command

```
pip-requirements install [-h] [--all] [--required] [--optional [OPTIONAL ...]] [--pip PIP] [--dry] pyproject_toml

positional arguments:
pyproject_toml        pyproject.toml

optional arguments:
-h, --help            show this help message and exit
--all                 Install dependencies from all known sections (required and optional).
--required            Install required dependencies.
--optional [OPTIONAL ...]
Optional dependency to install. May be specified multiple times.
--pip PIP             Pip tool to use. Autodetected. Default: /home/nate/.local/bin/pip
--dry                 Dry run
```

### `txt` Command


```
pip-requirements txt [-h] [--all] [--required] [--optional [OPTIONAL ...]] pyproject_toml [output_file]

Generate a requirements.txt files for compatibility.

positional arguments:
  pyproject_toml        pyproject.toml
  output_file           path to a file to output. stdout otherwise.

optional arguments:
  -h, --help            show this help message and exit
  --all                 Include dependencies from all known sections (required and optional).
  --required            Include required dependencies.
  --optional [OPTIONAL ...]
                        Include optional dependency. May be specified multiple times.
```


## Future

We should have something like:

```shell
pip install --optional=name --required --all path/to/pyproject.toml
```

Or:

```shell
pip requirements install --all path/to/pyproject.toml
```


## Links

- [Source](https://hg.sr.ht/~metacompany/pip-requirements) (Source Hut)
TREEplusrepository 0.1.7
Standard and Non-Standard Tree Based Methods
Keywords: python, tree, CART

The library contains standard CART based methologies for growing trees, includind twoing, as well as non standard techniques two-stage techniques like fast and latent-budget tree. There is also cross validation methods for pruning the tree, and k-folds implementation. As well as a graphical interface to view the tree and information about the nodes, including visual pruning by viewing thhe decrease in deviance created by a split relative to other splits in the grown tree, and an output table containing useful information.
BigFlowPrototypes 0.1
A package for preprocessing data for AI models
Requires Python: >=3.6

# BigFlowPrototypes

A package for preprocessing data for AI models.

## Modules

### Image.py

Processes image data using VGG16 to convert it to vector data and store it in a database.

### linearEmbed.py

Prepares a "normal dataset" and converts non-numeric columns to embedded data using OpenAI embedding.

### Linear.py

Removes non-numeric data and inputs it into a model.

## Installation

```bash
pip install BigFlowPrototypes


from data_preprocessor import linearEmbed

if __name__ == "__main__":
    input_data_path = 'titanic.csv'  # Path to the input data file
    label_column = 'Survived'  # Name of the label column
    columns_to_embed = ['Name']  # Columns to embed
    openai_api_key = 'your_openai_api_key'  # OpenAI API key
    
    X_train, X_test, y_train, y_test = linearEmbed.main(input_data_path, label_column, columns_to_embed, openai_api_key)
    print("Data processing complete.")


from data_preprocessor import Linear

if __name__ == "__main__":
    input_file = 'movies.csv'  # Path to the input data file
    label = 'Popularity'  # Name of the label column
    
    X_train, X_test, y_train, y_test = Linear.main(input_file, label)
    print("Data processing complete.")