semvec/pypi-packages huggingface dataset:
futureframe 0.2.5
Accelerate your data science workflow from months to days with foundation models for tabular data.
Requires Python: <4.0,>=3.10
Keywords: data science, foundation models, tabular data

# 💠 Future Frame

Empowering Data Scientists with Foundation Models for Tabular Data

- This Python package allows you to interact with pre-trained foundation models for tabular data.
- Easily fine-tune them on your classification and regression use cases in a single line of code.
- Interested in what we're building? Join our [waitlist](https://futureframe.ai/)!

## Installation

1. Install Future Frame with `pip` – more details on our [PyPI page](https://pypi.org/project/futureframe/).

```bash
pip install futureframe
```

## Quick Start

Use Future Frame to fine-tune a pre-trained foundation model on a classification task.

```python linenums="1"
# Import standard libraries
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.metrics import roc_auc_score

# Import Future Frame
import futureframe as ff

# Import data
dataset_name = "https://raw.githubusercontent.com/futureframeai/futureframe/main/tests/data/churn.csv"
target_variable = "Churn"
df = pd.read_csv(dataset_name)

# Split data
X, y = df.drop(columns=[target_variable]), df[target_variable]
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3)

# Fine-tune a pre-trained classifier with Future Frame
model = ff.models.cm2.CM2Classifier()
model.finetune(X_train, y_train)

# Make predictions with Future Frame
y_pred = model.predict(X_test)

# Evaluate your model
auc = roc_auc_score(y_test, y_pred)
print(f"AUC: {auc:0.2f}")
```

## Models

| Model Name | Paper Title                                                | Paper                                               | GitHub                                 |
| ---------- | ---------------------------------------------------------- | --------------------------------------------------- | -------------------------------------- |
| CM2        | Towards Cross-Table Masked Pretraining for Web Data Mining | [Ye et al., 2024](https://arxiv.org/abs/2307.04308) | [Link](https://github.com/Chao-Ye/CM2) |

More foundation models will be integrated into the library soon. Stay tuned by joining our [waitlist](https://futureframe.ai/)!

## Links

- [Future Frame Official Website](https://futureframe.ai/)
- [Future Frame API Reference](https://futureframe.ai/api-reference/)
- [`futureframe` PyPI Page](https://pypi.python.org/pypi/futureframe)
- [`futureframe` GitHub Repository](https://github.com/futureframeai/futureframe)
- [`futureframe` Documentation](https://futureframe.ai/docs/)

## Contributing

- We are currently under heavy development.
- If you'd like to contribute, please send us an email at <i>eduardo(at)futureframe.ai</i>.
- To report a bug, please write an [issue](https://github.com/futureframeai/futureframe/issues/new).
memorydelaysmtphandler 1.0.2
MemoryDelaySmtpHandler will create a bundle of events in a single email and sent it after a delay.
Requires Python: >=3.8

# memorydelaysmtphandler

## Overview
**memorydelaysmtphandler** adds new handlers for the Python logging package.

Issue : SMTPHandler sends one email after each event. Multiple emails can be received in a short time.<br> 
Improvement : MemoryDelaySmtpHandler will create a bundle of events in a single email and sent it after a delay.

## Features

**MemoryDelayHandler** class adds an auto-flush delay to logging.handlers.MemoryHandler.<br>
**MemoryDelaySmtpHandler** class adds an auto-flush delay to logging.handlers.SMTPHandler.

#### The handler is flushed when:
- the number of events is equal to the capacity
- the event of a certain severity occurs
- after a first event, the delay is reached

#### New parameters
- Initializes the handler with a buffer of the specified capacity. Here, capacity means the number of events records buffered.
- A delay in seconds to automatically flush the buffer after a first event. When the delay argument is not present or None, no automatic flushed is provided.

## Installation
```
$ python3 -m pip install memorydelaysmtphandler
```



## Using with OpenCanary

logging.handlers.SMTPHandler sends one email after each alert. Multiple emails can be received in a short time.<br> 
MemoryDelaySmtpHandler will create a bundle of alerts in a single email and sent it after a delay.

#### Installation for OpenCanary
Install memorydelaysmtphandler in the OpenCanary environment.

#### Edit /etc/opencanaryd/opencanary.conf
Change "class": "logging.handlers.SMTPHandler"<br>
by     "class": "memorydelaysmtphandler.memorydelaysmtphandler.MemoryDelaySmtpHandler"

add these parameters:
```
	"capacity" : your capacity,
	"delay" : your delay
```    

Example:
```
// [..] # Services configuration
    "logger": {
    "class" : "PyLogger",
    "kwargs" : {
        "handlers": {
            "SMTP": {
                "class": "memorydelaysmtphandler.memorydelaysmtphandler.MemoryDelaySmtpHandler",
                "mailhost": ["smtp.gmail.com", 587],
                "fromaddr": "noreply@yourdomain.com",
                "toaddrs" : ["youraddress@gmail.com"],
                "subject" : "OpenCanary Alert",
                "credentials" : ["youraddress", "abcdefghijklmnop"],
                "secure" : [],
                "capacity" : 128,
                "delay" : 60                
             }
         }
     }
 }
 ```