semvec/pypi-packages huggingface dataset:
bizkit 0.0.4
A package that streamlines business data analytics


# <img alt="bizkit" src="logo.jpg" height="300" width="300">


# bizkit

bizkit is a Python package to help streamlining business analytics data mining tasks. This package provides methods for market basket analysis, anomaly detection, customer survival analysis, customer clustering, and uplifting analysis. Implemented algorithms include mlxtend.apriori, sklearn.IsolationForest, lifelines.KaplanMeierFitter, [], and []. bizkit focuses on ease of use by providing a well-documented and consistent interface. The results are visualized via bokeh library, d3fgraph library, and [].


# Reference

Market basket analysis:
- Introduction to Market Basket Analysis in Python https://pbpython.com/market-basket-analysis.html
- A Gentle Introduction on Market Basket Analysis — Association Rules https://towardsdatascience.com/a-gentle-introduction-on-market-basket-analysis-association-rules-fa4b986a40ce



Anomaly detection:
- Anomaly Detection Principles and Algorithms (2017) by Kishan G. Mehrotra, Chilukuri K. Mohan, HuaMing Huang
- Sklearn IsolationForest: https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.IsolationForest.html


Time-to-event analysis:
- Lifelines https://lifelines.readthedocs.io/en/latest/


Customer clustering:
- Understanding K-means Clustering in Machine Learning https://towardsdatascience.com/understanding-k-means-clustering-in-machine-learning-6a6e67336aa1


Uplift Modeling:
- Simple Machine Learning Techniques To Improve Your Marketing Strategy: Demystifying Uplift Modelshttps://medium.com/datadriveninvestor/simple-machine-learning-techniques-to-improve-your-marketing-strategy-demystifying-uplift-models-dc4fb3f927a2


# Author
Bassim Eledath, Lynn He, Christine Zhu, Amanda Ma
gkms 0.0.1
A simple utility for using GCP Cloud KMS to encrypt and decrypt secrets and storing them in GCS.
Keywords: cloudgcp,gcs,google,google-cloud-kms,google-cloud-storage,kms,encrypt,decrypt

# gkms

`gkms` is a simple utility for using GCP Cloud KMS to encrypt and decrypt secrets and storing them in GCS.

## Installation

```shell
pip install gkms
```

## Setup

Please see [https://googleapis.github.io/google-cloud-python/latest/core/auth.html](https://googleapis.github.io/google-cloud-python/latest/core/auth.html) for authentication with Google Cloud SDK.

## Usage

### CLI

```shell
gkms encrypt \
    --project my-project \
    --location global \
    --ring my-key-ring \
    --key my-crypto-key \
    --bucket my-bucket \
    --target my-target.txt \
    --secret my-secret.txt

gkms decrypt \
    --project my-project \
    --bucket my-bucket \
    --target my-target.txt

gkms reencrypt \
    --project my-project \
    --bucket my-bucket \
    --target my-target.txt
```

### Python

```python
import gkms

gkms.encrypt(
    project='my-project',
    location='global',
    keyring='my-key-ring',
    cryptokey='my-crypto-key',
    bucket='my-bucket',
    target='my-secret.txt',
    secret_name='my-secret.txt',
)

decrypted = gkms.decrypt(
    project='my-project',
    bucket='my-bucket',
    target='my-secret.txt',
)

gkms.reencrypt(
    project='my-project',
    bucket='my-bucket',
    target='my-secret.txt',
)
```

## Contributing

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

### Getting Started

Set up your virual environment however you like.

```shell
pip install -e .[dev]
```

You're ready to start developing!

### Running Tests

```shell
pytest
```

## Disclaimer

`gkms` merely allows you to keep your secrets in GCS buckets allowing you to specify permissions via IAM roles. _This does **not** replace projects like HashiCorp Vault!_ Attackers who gain access to your service accounts will have access to the secrets.
imagine-client-py 0.3.0
A python client for doc.ai's Imagine API

# Imagine Client for Python

This library allows you to easily connect to doc.ai's Imagine API.

## Supported Image Models

Model Id       | Type  | Description |
---------------|-------|-------------|
phenomenal-face| image | Given a facial image, this model infers the age, sex, height, and weight of a person |
happy-face     | image | Given a facial image, this model infers the mood of a person |
manna     | image | Given a food image, this model infers whether the food is healthy/unhealthy |
face-detector     | image | Given an image, this model detects whether a face is present |
food-detector     | image | Given an image, this model detects whether food is present | 


## API

```ImageBasedModel.create(imagine_client, model_id)```

> Given an ImagineClient (imagine_client) and string (model_id), creates an image model. See the *"Supported Image Models"* section for a list of supported model ids.

```ImageBasedModel.infer(image_file_stream, store=false, metadata=None)```

> Performs the model's inference on an image. A read stream should be passed as the parameter (image_file_stream).

```ImageBasedModel.insert_correction(corrections_dict, metadata=None)```

> Uploads a correction label to the imagine API, for a given inference.

```ImageBasedModel.insert_prediction(predictions_dict, metadata=None)```

> (FOR EDGE PREDICTIONS) Uploads a prediction label to the imagine API, for a given inference.

### Example

```python

from imagine_client_py import ImagineClient, ImageBasedModel

# Required parameters
API_KEY = <VALID_IMAGINE_API_KEY>
IMAGE_PATH = <IMAGE_FILE_PATH>
CLIENT_ID = <ANY_CLIENT_ID>

# Initialize imagine client
imagine_client = ImagineClient({
  'api_key': API_KEY,
  'client_id': CLIENT_ID
})

# Create the 'happy-face' model interface
model = ImageBasedModel.create(imagine_client, 'happy-face')

# Create a read stream to a image file
with open(IMAGE_PATH, 'rb') as image_face_file:
  # Perform the model's inference, on the image.
  result = model.infer(image_face_file)
```


##Tests

To run tests:
```
export IMAGINE_API_KEY=<API key> IMAGINE_CLIENT_ID=test
pytest
```