Metadata-Version: 2.1
Name: mmanager
Version: 2.3.1
Summary: Modelmanager API With Insight Generation and Pycausal
Author: falcon
License: MIT
Classifier: Programming Language :: Python :: 3
Classifier: License :: OSI Approved :: MIT License
Classifier: Operating System :: OS Independent
Description-Content-Type: text/markdown
License-File: LICENSE.txt
Requires-Dist: requests
Requires-Dist: colorama

﻿# Welcome to Modelmanager-api!

## This is a api model for interacting with modelmanager.

> **Note:**
>
> - Example files are are in example_script directory.
> - Example assets are in assets directory.
> - It contains scripts for different actions(Add, Update, Delete).
> - Check logs from file mmanager_log.log

---

## **Example Codes**

## Add Applications
```python
from mmanager.mmanager import Applications
secret_key = 'Secret-Key'
url = 'URL'
application_data = {
    "name":""
}
Applications(secret_key,url).post_application(data=application_data)
```

## Add Classification/Regression
```python
from mmanager.mmanager import Usecase
secret_key = 'Secret-Key'
url = 'URL'
data = {
        "name": "Determination Of Origin Of Wine Using Chemical Analysis",
        "description": "Wine is one of the most popular alcoholic drinks which has been used for thousands of years. Wine is produced by fermenting grapes.", #(Optional)
        "image": '/path/image.jpg', #(Optional)
	}
Usecase(secret_key, url).post_usecase(data)
```
#### Other optional data 
| Key word | Example |
| ----------- | ----------- |
| author | John Doe |
| usecase_type | Classification (Options: Classification, Regression, Forecasting) |
| computing_type | Classical (Options: Classical, Qantum, Hybrid) |
| source | Forina, M. et al, PARVUS -An Extendible Package for Data Exploration, Classification and Correlation.,Institute of Pharmaceutical and Food Analysis and Technologies, Via Brigata Salerno,16147 Genoa, Italy.  |
| contributor | S. Aeberhard, D. Coomans and O. de Vel, Comparison of Classifiers in High Dimensional Settings, Tech. Rep. no. 92-02, (1992), Dept. of Computer Science and Dept. of Mathematics and Statistics, James Cook, University of North Queensland. |
| is_private | Set True to keep the usecase private. Default False. |
| trustability | Set True to list in trustability. Default False. |
| explainability | Set True to list in explainability. Default False. |
| hide_model | Set True to hide model related to this usecase. Default False. |
| notification_emails | List of emails that will be notified. Eg: johndoe@qausal.com, adams_mary@qausal.com |
---

## Forecasting Usecase
```python
usecase_info = {
    "name": "",
    "usecase_type": "Forecasting",
    "author": "",
    "description": "",
    "source": "",
    "contributor": "",
    "image": "",
    "performance_data_selection": "",
    "applications": ""
}

forecasting_fields = {
    "performance_data_selection": "",#eg:{'from':'2020-09-09', 'to':'2020-11-01'}
    "notification_emails": ["jhon@email.com"],
    "forecasting_template": "two_conditions"
}


forecasting_feature_tabs = {
    "result_tab":True,
    "series_tab":True,
    "condition_tab":True,
    "performance_tab":True,
    "ab_testing_tab":True,
    "release_tab":True
}
Usecase(secret_key,url).post_usecase(usecase_info, forecasting_fields, forecasting_feature_tabs)
```

## Update Usecase

```python
from mmanager.mmanager import Usecase
secret_key = 'Secret-Key'
url = 'URL'
project_id = Project_id #use model_id number to update
data = {
		"author": "AuthorName",
		"description": "UsecaseDescription",
		"source": "UsecasSource",
		"contributor": "UsecaseContributor",
		"image": 'image.jpg' , #path to image file
		"banner": 'banner.jpg' , #path to banner file
	}
Usecase(secret_key, url).patch_usecase(data, project_id)
```

---
# Get All Usecases Uploaded By Authenticated User
```python
from mmanager.mmanager import Usecase
secret_key = 'Secret-Key'
url = 'URL'
usecases = Usecase(secret_key,url).get_usecases()
print(usecases)
```
---

# Get Usecase Detail
```python
from mmanager.mmanager import Usecase
secret_key = 'Secret-Key'
url = 'URL' 
usecase_id = "Usecase-Id"

# GET USECASE DETAIL
usecase_detail = Usecase(secret_key,url).get_detail(usecase_id)
print(usecase_detail)

# GET ALL USECASE UPLOATED BY AUTHENTICATED USER
_usecases = Usecase(secret_key,url).get_usecases()
print(_usecases)

# GET ALL MODEL ID REGISTERED UNDER USECASE
model_list = Usecase(secret_key,url).get_models(usecase_id)
print(model_list)
```
---

## Delete Project

```python
from mmanager.mmanager import Usecase
secret_key = 'Secret-Key'
url = 'URL'
project_id = Project_id #use project_id number to delete
Usecase(secret_key,url).delete_usecase(project_id)
```
---

## Add Related Database
```python
from mmanager.mmanager import ExternalDatabase
secret_key = 'Secret-Key'
url = 'URL'
# db_type: Postgres, MySQL
related_db_data ={
    "db_type":"Postgres",
    "db_name":"db_name",
    "db_user":"username",
    "db_password":"db_pass",
    "db_host":"localhost",
    "db_port":"5432"
}
ExternalDatabase(secret_key,url).post_related_db(data=related_db_data)
```
## Link External Database
``` python
from mmanager.mmanager import ExternalDatabase
secret_key = 'Secret-Key'
url = 'URL'
# link_type: Client, System
external_db_data = {
    "link_type":"System",
    "usecase":"usecase_id",
    "external_db":"related_db_id",
    "train_table":"",
    "test_table":"",
    "pred_table":"",
    "actuals_table":""
}
ExternalDatabase(secret_key,url).link_externaldb(data=external_db_data)
```

## Add Tables
``` python
from mmanager.mmanager import TableInfo
secret_key = 'Secret-Key'
url = 'URL'
table_data = {
    "table_type":"" #eg:"actual",
    "table_name": "" #eg:"daily_act2",
    "db_link": #eg:11
    }

TableInfo(secret_key,url).post_table_info(data=table_data)
```

## Add Fields
``` python
from mmanager.mmanager import FieldInfo
secret_key = 'Secret-Key'
url = 'URL'
field_data = {
    "table_id": "" #eg:9,
    "display_name": "" #eg:actual2,
    "field_type": "",
    "field_name":""
    }
FieldInfo(secret_key,url).post_field_info(data=field_data)
```

## Load Database Cache
``` python
from mmanager.mmanager import Usecase
secret_key = 'Secret-Key'
url = 'URL'
Usecase(secret_key,url).load_cache(usecase_id=7)
```
---

## Add Model 

```python
from mmanager.mmanager import Model
secret_key = 'Secret-Key'
url = 'URL'
path = 'assets' #path to csv file

model_data = {
    "project": "1", #Project ID or Usecase ID
    "transformerType": "Classification", #Options: Classification, Regression, Forcasting
    "datasetinsertionType": "Manual" #Options: AzureML, External DB, Manual
    "training_dataset": "/path/train.csv"
    "test_dataset": "/path/test.csv"
    "pred_dataset": "/path/pred.csv"
    "actual_dataset": "/path/truth.csv"
    "model_file_path": "/path/model.h5"
    "target_column": "Class"
}
Model(secret_key, url).post_model(model_data)
```

#### Other optional data 
| Key word | Example |
| ----------- | ----------- |
| note |  |
| model_area |  |
| model_dependencies |  |
| model_usage |  |
| model_audjustment |  |
| model_developer |  |
| model_approver |  |
| model_maintenance |  |
| documentation_code |  |
| production | Production (Options: production, observation, retired) |
| model_input_data | "/path/input.csv" (Path to input data.) |
| computing_type | Classical (Options: Classical, Qantum, Hybrid) |
| binarize_scoring_flag | Set True to label binarize. Default False. |
| algorithmType | Xgboost (Options: Xgboost, GBM) |
| modelFramework | driverless_ai (Options: driverless_ai, tensorflow, keras, scikit, statmodlib, other) |
---

## Create Config File For Azure ML Credentials
- Get Credentials from your existing Azure ML account.
- Create a config file in following format 
- Give credential file path in credPath field to enable using AML integration service.

```json
{
    "subscription_id": "<subscription-id>",
    "resource_group": "<resource_group>",
    "workspace_name": "<workspace_name>",
    "tenant-id": "<tenant-id>",
    "datastore_name": "<datastore_name>"
}
```
## Add Model, Fetch Datasets And Model From Azure ML

```python
from mmanager.mmanager import Model
secret_key = 'Secret-Key'
url = 'URL'
model_data = {
    "project": "<project-id>", #Project ID or Usecase ID
    "transformerType": "model-type", #Options: Classification, Regression, Forcasting 
    "target_column": "target-column-name", #Target Column
    }

ml_options = {
    "credPath": "config.json", #Path to Azure ML credential files.
    "datasetinsertionType": "AzureML", #Option: AzureML, Manual
    "fetchOption": ["Model"], #To fetch model, add ["Model", "Dataset"] to fetch both model and datasets.
    "modelName": "model-name", #Fetch model file registered with model name.
    "dataPath": "dataset-name", #Get datasets registered with dataset name.
    }
Model(secret_key, url).post_model(model_data, ml_options)
```
## Add Model, Upload Datasets And Model Manually And Register To Azure ML

```python
from mmanager.mmanager import Model
secret_key = 'Secret-Key'
url = 'URL'
path = 'assets' #path to csv file
model_data = {
    "project": "1", #Project ID or Usecase ID
    "transformerType": "Classification", #Options: Classification, Regression, Forcasting
    "datasetinsertionType": "Manual" #Options: AzureML, External DB, Manual
    "training_dataset": "/path/train.csv"
    "test_dataset": "/path/test.csv"
    "pred_dataset": "/path/pred.csv"
    "actual_dataset": "/path/truth.csv"
    "model_file_path": "/path/model.h5"
    "target_column": "Class"
}

ml_options = {
    "credPath": "config.json", #Path to Azure ML credential files.
    "datasetinsertionType": "Manual", #Option: AzureML, Manual
    "registryOption": ["Model"], #To register model, add ["Model", "Dataset"] to register both model and datasets.
    "datasetUploadPath": "dataset-name", #To registere dataset on path.
    }
Model(secret_key, url).post_model(model_data, ml_options)
```
---

## Update Model

```python
from mmanager.mmanager import Model
secret_key = 'Secret-Key'
url = 'URL'
model_id = Model_id #use model_id number to update
data = {
		"transformerType": "logistic",
		"target_column": "id",
		"training_dataset": "train.csv", #path to csv file
		"pred_dataset": "submissionsample.csv", #path to csv file
		"actual_dataset": "truth.csv", #path to csv file
		"test_dataset": "test.csv", #path to csv file
	}
Model(secret_key, url).patch_model(data, model_id)
```

---

# Delete Model

---

```python
from mmanager.mmanager import Model
secret_key = 'Secret-Key'
url = 'URL'
model_id = "Model_id" #use model_id number to delete
Model(secret_key,url).delete_model(model_id)
```

---

---
# Get Model Details
```python
from mmanager.mmanager import Model
secret_key = 'Secret-Key'
url = 'URL'
model_id = "Model_id" 
Model(secret_key,url).get_details(model_id)
```
---

---
# Get Metrics
 - Get latest metrics recorded under Model
 - Metric Type
    * Developement Metric
    * Scoring Metric
```python
from mmanager.mmanager import Model
secret_key = 'Secret-Key'
url = 'URL'
metric = Model(secret_key,url).get_latest_metrics(model_id="Model-Id", metric_type="Metric-Type")
```
---

# Generate Model Report
---
```python
from mmanager.mmanager import Model
secret_key = 'Secret-Key'
url = 'URL'
model_id = "Model-Id" #use model_id number
Model(secret_key,url).generate_report(model_id)
```
---

# Get Model Report
---
```python
from mmanager.mmanager import Model
secret_key = 'Secret-Key'
url = 'URL'
model_id = "Model-Id" #use model_id number
all_report = Model(secret_key,url).get_all_reports(model_id=model_id)
```
---
