vijil 0.1.16__tar.gz

vijil-0.1.16/PKG-INFO

@@ -0,0 +1,15 @@
+Metadata-Version: 2.1
+Name: vijil
+Version: 0.1.16
+Summary: The official Python client for Vijil
+Author: vijil
+Author-email: contact@vijil.ai
+Requires-Python: >=3.9,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Dist: click
+Requires-Dist: python-dotenv (>=1.0.0,<2.0.0)
+Requires-Dist: requests (>=2.26.0,<3.0.0)
+Requires-Dist: tabulate

vijil-0.1.16/pyproject.toml

@@ -0,0 +1,21 @@
+[tool.poetry]
+name = "vijil"
+version = "0.1.16"
+description = "The official Python client for Vijil"
+authors = [
+    "vijil <contact@vijil.ai>"
+]
+
+[tool.poetry.dependencies]
+python = "^3.9"
+requests = "^2.26.0"
+python-dotenv = "^1.0.0"
+click = "*"
+tabulate = "*"
+
+[build-system]
+requires = ["poetry-core>=1.0.0"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.poetry.scripts]
+vijil = "vijil.cli:main"

vijil-0.1.16/vijil/__main__.py

@@ -0,0 +1,4 @@
+from vijil.cli import main
+
+if __name__ == "__main__":
+    main()

vijil-0.1.16/vijil/cli.py

@@ -0,0 +1,26 @@
+import click
+from vijil.commands.authentication import login, logout
+from vijil.commands.create import create
+from vijil.commands.describe import describe
+from vijil.commands.download import download
+from vijil.commands.start import start
+from vijil.commands.stop import stop
+from vijil.commands.delete import delete
+from vijil.commands.list import list
+
+@click.group()
+def main():
+    """VIJIL Command Line Interface"""
+
+main.add_command(login)
+main.add_command(logout)
+main.add_command(start)
+main.add_command(stop)
+main.add_command(describe)
+main.add_command(delete)
+main.add_command(download)
+main.add_command(list)
+main.add_command(create)
+
+if __name__ == '__main__':
+    main()

vijil-0.1.16/vijil/commands/authentication.py

@@ -0,0 +1,31 @@
+import click
+import requests
+from vijil.vijilapi.api_handler import VIGIL_API_BASE_URL
+from vijil.vijilapi.config_handler import remove_config, save_config
+
+@click.argument('username')
+@click.option('--token', prompt='Enter your token', hide_input=True)
+@click.command()
+def login(username, token):
+    """[username]"""
+    click.echo(f"Verifying your credentials...")
+    verify_url = f"{VIGIL_API_BASE_URL}/tokens/verify"
+    data = {"username": username, "token": token}
+
+    try:
+        response = requests.post(verify_url, json=data)
+        response.raise_for_status()
+
+        if response.json().get("verify"):
+            save_config(username, token)
+            click.echo("Token verified.")
+        else:
+            click.echo("Token verification failed. Please try a different token.")
+
+    except requests.exceptions.RequestException as e:
+        click.echo(f"Error during API request: {e}")
+
+@click.command()
+def logout():
+    remove_config()
+    click.echo("Logout done")

vijil-0.1.16/vijil/commands/create.py

@@ -0,0 +1,23 @@
+import click
+from vijil.evaluations.options import MODEL_HUB_CHOICES, MODEL_TYPE_MAPPING
+from vijil.vijilapi.api_handler import model_token_request
+
+@click.group()
+def create():
+    """[token]"""
+    pass
+
+@create.command()
+@click.argument('source', type=click.Choice(MODEL_HUB_CHOICES))
+@click.option('--name', prompt='Enter the name of token')
+@click.option('--token', prompt='Enter the token')
+@click.option('--is-primary', prompt='Do you want to make this token as the default?', type=click.Choice(['yes', 'no']))
+def token(source, name, token, is_primary):
+    isPrimary = "true" if is_primary == 'yes' else "false"
+    try:
+        result = model_token_request(MODEL_TYPE_MAPPING.get(source), name, token, isPrimary)
+        if result:
+            click.echo(f"Successfully saved integration token.")
+
+    except ValueError as e:
+        click.echo(f"Error: {e}")

vijil-0.1.16/vijil/commands/delete.py

@@ -0,0 +1,20 @@
+import click
+
+from vijil.vijilapi.api_handler import delete_job_request
+
+@click.group()
+def delete():
+    """[evaluation]"""
+    pass
+
+@delete.command()
+@click.option('--id', prompt='Enter ID that you received while creating evaluation', type=str)
+def evaluation(id):
+    click.echo(f"Deleting evaluation with ID: {id}")
+    try:
+        result = delete_job_request(id)
+        if result:
+            click.echo(f"{result.get('message')}") 
+
+    except ValueError as e:
+        click.echo(f"Error: {e}")

vijil-0.1.16/vijil/commands/describe.py

@@ -0,0 +1,85 @@
+import time
+import click
+from vijil.utils import find_job_by_task_id, format_datetime
+
+from vijil.vijilapi.api_handler import check_jobs_progress, job_status_request, list_job_request
+
+@click.group()
+def describe():
+    """[evaluation | log]"""
+    pass
+
+@describe.command()
+@click.option('--id', prompt='Enter ID that you received while creating evaluation', type=str)
+@click.option('--trail', is_flag=True, help='Print live logs for in-progress jobs')
+def log(id, trail):
+    printed_lines = set()
+    try:
+        joblist = list_job_request()
+        matched_job = find_job_by_task_id(joblist, id)
+        if matched_job:
+            if matched_job.get('status') == 'In Progress':
+                if trail:
+                    while True:
+                        live_logs = check_jobs_progress(id)
+                        for log in live_logs.get('progress'):
+                            if log not in printed_lines:
+                                print(log)
+                                printed_lines.add(log)
+                        time.sleep(5)
+                else:
+                    print("Job is still in progress. Use --trail to get live logs.")
+            else:
+                result = [matched_job.get('job_result')] if matched_job.get('status') == "Stopped" else matched_job.get('output')
+                for item in result:
+                    print(item)
+        else:
+            print("No matching job found.")
+
+    except ValueError as e:
+        error_detail = str(e)
+        if error_detail == "400: Job is already completed.":
+            joblist = list_job_request()
+            matched_job = find_job_by_task_id(joblist, id)
+            result = [matched_job.job_result] if matched_job.get('status') == "Stopped" else matched_job.get('output')
+            for item in result:
+                if item not in printed_lines:
+                    print(log)
+                    printed_lines.add(log)
+        else:
+            click.echo(f"Error: {error_detail}")           
+
+@describe.command()
+@click.option('--id', prompt='Enter ID that you received while creating evaluation', type=str)
+def evaluation(id):
+    click.echo(f"Getting job status for ID: {id}")
+    try:
+        result = job_status_request(id)
+        if "job_result" in result:
+            click.echo(f"Job Status: {result.get('status')}") 
+            click.echo(f"Job Result: {result.get('job_result')}")
+        elif "status" in result:
+            click.echo(f"Job Status: {result.get('status')}") 
+        elif isinstance(result, type([])) and len(result) > 0:
+            click.echo("-" * 60)
+            for job in result:
+                click.echo(f"Job ID: {job.get('job_id', '')}")
+                click.echo(f"Model Hub: {job.get('model_type', '')}")
+                click.echo(f"Model Name: {job.get('model_name', '')}")
+                click.echo(f"Probe Group: {job.get('probe_group', '')}")
+                click.echo("Probes:")
+                for probe in job.get('probe', []):
+                    click.echo(f"  - {probe}")
+
+                click.echo("Detectors:")
+                for detector in job.get('detector', []):
+                    click.echo(f"  - {detector}")
+                click.echo(f"Start Time: {format_datetime(job.get('start_time', ''))}")
+                click.echo(f"Report: {job.get('report', '')}")
+                click.echo(f"Hitlog: {job.get('hitlog', '')}")
+                click.echo("-" * 60)
+        else:
+            click.echo("No data found.")
+
+    except ValueError as e:
+        click.echo(f"Error: {e}")

vijil-0.1.16/vijil/commands/download.py

@@ -0,0 +1,28 @@
+import click
+
+from vijil.vijilapi.api_handler import download_report_request, job_status_request
+
+@click.group()
+def download():
+    """[log]"""
+    pass
+
+@download.command()
+@click.argument("report_type", type=click.Choice(["full", "failure"]))
+@click.option('--id', prompt='Enter ID that you received while creating evaluation', type=str)
+def log(report_type, id):
+    """[full | failure]"""
+    try:
+        result = job_status_request(id)
+        if isinstance(result, type([])) and len(result) > 0:
+            file_id = result[0].get("report" if report_type == "full" else "hitlog")
+            result = download_report_request(file_id)
+            if result:
+                click.echo(f"{result}")
+            else:
+                click.echo("No data found.")
+        else:
+            click.echo("No data found")
+
+    except ValueError as e:
+        click.echo(f"Error: {e}")

vijil-0.1.16/vijil/commands/list.py

@@ -0,0 +1,70 @@
+import click
+
+from tabulate import tabulate
+from vijil.utils import format_datetime, get_dimensions_from_probe_groups
+from vijil.vijilapi.api_handler import get_model_token_request, list_job_request
+
+@click.group()
+def list():
+    """[evaluations | tokens]"""
+    pass
+
+@list.command()
+def tokens():
+    try:
+        result = get_model_token_request()
+        if len(result) > 0:
+            table_data = []
+            for token in result:
+                table_data.append([
+                    token.get('name', ''),
+                    token.get('type', ''),
+                    token.get('token', ''),
+                    token.get('isPrimary', '')
+                ])
+
+            headers = ["Name", "Type", "Token", "isDefault"]
+            colalign = ['left'] * len(headers)
+            tablefmt = "heavy_grid"
+            maxcolwidths = [None, None, 50, None]
+
+            table = tabulate(table_data, headers=headers, tablefmt=tablefmt, colalign=colalign, maxcolwidths=maxcolwidths)
+            click.echo(table)
+        else:
+            click.echo("No tokens found.")
+
+    except ValueError as e:
+        click.echo(f"Error: {e}")
+
+@list.command
+def evaluations():
+    try:
+        result = list_job_request()
+        if len(result) > 0:
+            table_data = []
+            for job in result:
+                probe_groups_list = job.get('probe_group', '').split(",")
+                table_data.append([
+                    job.get('id', ''),
+                    job.get('model_type', ''),
+                    job.get('model_name', ''),
+                    "\n".join(get_dimensions_from_probe_groups(probe_groups_list)),
+                    "\n".join(probe_groups_list),
+                    job.get('status', ''),
+                    job.get('job_result', ''),
+                    format_datetime(job.get('start_time', '')),
+                    format_datetime(job.get('end_time', ''))
+                ])
+
+            headers = ["ID", "Model Hub", "Model Name", "Dimension", "Probe Group", "Status", "Output", "Start Time", "End Time"]
+            maxcolwidths = [None, 10, 25, None, None, None, 30, None, None]
+
+            colalign = ['left'] * len(headers)
+            tablefmt = "heavy_grid"
+            table = tabulate(table_data, headers=headers, tablefmt=tablefmt, colalign=colalign, maxcolwidths=maxcolwidths)
+            click.echo(table)
+        else:
+            click.echo("No jobs found.")
+
+    except ValueError as e:
+        click.echo(f"Error: {e}")

vijil-0.1.16/vijil/commands/start.py

@@ -0,0 +1,40 @@
+import click
+
+from vijil.evaluations.options import DTYPE_CHOICES, MODEL_HUB_CHOICES, PROBES_CHOICES, PROBES_DIMENSIONS_MAPPING
+from vijil.utils import generate_default_job_name
+from vijil.vijilapi.api_handler import get_headers, list_job_request, send_evaluation_request
+
+@click.group()
+def start():
+    """[evaluation]"""
+    pass
+
+@start.command()
+@click.option('--model-hub', prompt='Choose the model hub', type=click.Choice(MODEL_HUB_CHOICES))
+@click.option('--model-name', prompt='Enter the model name')
+@click.option('--dimension', prompt='Choose the trust dimension', type=click.Choice(PROBES_CHOICES))
+@click.option('--deployment-type', prompt='Choose the deployment type', type=click.Choice(DTYPE_CHOICES))
+@click.option('--generations', default=1, prompt='Enter the number of generations', type=click.IntRange(1, 100))
+@click.option('--token', default='', prompt='Enter the model token')
+def evaluation(model_hub, model_name, dimension, deployment_type, generations, token):
+    try:
+        headers = get_headers()
+        if model_hub != 'huggingface' and deployment_type == 'local':
+            click.echo(f"Local deployment type is not allowed for model {model_hub}.")
+            return
+        
+        # probes = PROBES_DIMENSIONS_MAPPING.get(dimension)
+
+        click.echo(f"Running evaluation for model hub: {model_hub}, model name: {model_name}")
+        
+        job_name = generate_default_job_name(headers['username'], model_hub, model_name)
+        result = send_evaluation_request(model_hub, model_name, dimension, generations, job_name, deployment_type, token)
+
+        
+        if result.get("task_id"):
+            click.echo(f"Successfully created evaluation, check job status by ID: {result.get('task_id')}")    
+        else:
+            click.echo(f"Response: {result}")
+
+    except ValueError as e:
+        click.echo(f"Error: {e}")

vijil-0.1.16/vijil/commands/stop.py

@@ -0,0 +1,32 @@
+import click
+
+from vijil.vijilapi.api_handler import stop_all_job_request, stop_job_request
+
+@click.group()
+def stop():
+    """[evaluation]"""
+    pass
+
+@stop.command()
+@click.option('--id', default='', help='Enter ID that you received while creating evaluation')
+@click.option('-a', '--all', is_flag=True, help='Stop all running evaluations.')
+def evaluation(id, all):
+    if all:
+        click.echo(f"Stopping all running evaluations.")
+        try:
+            result = stop_all_job_request()
+            if result.get("status"):
+                click.echo(f"Job Status: {result.get('status')}") 
+        except ValueError as e:
+            click.echo(f"Error: {e}")
+    else:
+        if not id:
+            click.echo("Please provide the ID for stopping a specific job.")
+            return
+        click.echo(f"Stopping evaluation of ID: {id}")
+        try:
+            result = stop_job_request(id)
+            if result.get("status"):
+                click.echo(f"Job Status: {result.get('status')}") 
+        except ValueError as e:
+            click.echo(f"Error: {e}")

vijil-0.1.16/vijil/evaluations/options.py

@@ -0,0 +1,32 @@
+MODEL_HUB_CHOICES = ['huggingface', 'replicate', 'octo', 'openai', 'together', 'anyscale', 'mistral']
+MODEL_NAMES_MAPPING = {
+    'huggingface': ['gpt2', 'bigscience/bloom-560m', 'other'],
+    'replicate': ['replicate/llama-7b', 'replicate/llama-13b-lora', 'other'],
+    'octo': ['llama-2-7b-chat', 'other'],
+}
+PROBES_CHOICES = [
+            'Security', 'Toxicity', 'Hallucination', 
+            'Ethics',"Privacy", "Stereotype", 
+            "Fairness", "Robustness"
+        ]
+PROBES_DIMENSIONS_MAPPING = {
+    'security': 'dan,encoding,gcg,glitch,knownbadsignatures,replay,malwaregen,packagehallucination,promptinject,xss',
+    'toxicity': 'atkgen,continuation,realtoxicityprompts',
+    'hallucination': 'goodside,snowball,misleading,packagehallucination',
+    'ethics': 'lmrc,hendrycksethics',
+    'privacy': 'leakreplay,replay',
+    'stereotype': 'advstereo',
+    'fairness': 'adultdata,winobias',
+    'robustness': 'advglue'
+}
+DTYPE_CHOICES = ['private', 'public']
+
+MODEL_TYPE_MAPPING = {
+    'huggingface': 'HF',
+    'replicate': 'Replicate',
+    'octo': 'Octo',
+    'openai': 'Open',
+    'together': 'together',
+    'anyscale': 'anyscale',
+    'mistral': 'mistral',
+}

vijil-0.1.16/vijil/utils.py

@@ -0,0 +1,42 @@
+from collections import Counter
+from datetime import datetime
+
+from vijil.evaluations.options import PROBES_DIMENSIONS_MAPPING
+
+def format_datetime(datetime_str):
+    """Format datetime from API response."""
+    if datetime_str:
+        try:
+            dt = datetime.strptime(datetime_str, "%Y-%m-%d %H:%M:%S")
+            return dt.strftime("%Y/%m/%d %H:%M")
+        except ValueError:
+            return datetime_str
+    else:
+        return datetime_str
+
+def find_job_by_task_id(job_list, target_task_id):
+    for job in job_list:
+        if job.get('id') == target_task_id:
+            return job
+    return None 
+
+def generate_default_job_name(username, model_hub, model_name):
+    current_date = datetime.now().strftime("%m%d%Y")
+    current_timestamp = datetime.now().strftime("%H%M%S")
+    job_name = '_'.join([username, model_hub, model_name, current_date, current_timestamp]).replace(" ", "")
+    return job_name
+
+def get_dimensions_from_probe_groups(probe_groups):
+    # Cleaning up empty strings here
+    probe_groups = [i for i in probe_groups if i]
+    
+    mapped_dimensions = []
+    
+    for group in probe_groups:
+        for dimension, probes in PROBES_DIMENSIONS_MAPPING.items():
+            dimension = dimension.capitalize()
+            if group in probes and dimension not in mapped_dimensions:
+                mapped_dimensions.append(dimension)
+                continue
+    
+    return sorted(mapped_dimensions)

vijil-0.1.16/vijil/vijilapi/api_handler.py

@@ -0,0 +1,137 @@
+# api_handler.py
+import requests
+import os
+import logging
+from .config_handler import load_config
+
+# VIGIL_API_BASE_URL = "http://127.0.0.1:8000/api/v1"
+# VIGIL_API_BASE_URL = "https://develop.vijil.ai/api/v1"
+VIGIL_API_BASE_URL = "https://score.vijil.ai/api/v1"
+
+# Set up logging
+HIDDEN_DIR_NAME = ".vijil"
+LOG_FILE_NAME = "vijil.log"
+LOG_FILE_PATH = os.path.join(os.path.expanduser('~'), HIDDEN_DIR_NAME, LOG_FILE_NAME)
+os.makedirs(os.path.dirname(LOG_FILE_PATH), exist_ok=True)
+logging.basicConfig(level=logging.ERROR, filename=LOG_FILE_PATH, filemode='a',
+                    format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+def get_headers():
+    username, token = load_config()
+    if not username or not token:
+        raise ValueError("To proceed, please log in by using the 'login' command..")
+    
+    return {
+        "username": username,
+        "clitoken": token,
+    }
+
+def make_api_request(endpoint, method="get", params=None, data=None):
+    url = f"{VIGIL_API_BASE_URL}/{endpoint}"
+    headers = get_headers()
+    
+    try:
+        if method.lower() == "get":
+            response = requests.get(url, params=params, headers=headers)
+
+        elif method.lower() == "post":
+            response = requests.post(url, json=data, params=params, headers=headers)
+        else:
+            raise ValueError("Invalid HTTP method. Use 'get' or 'post'.")
+
+        response.raise_for_status()
+        return response.json()
+
+    except requests.exceptions.HTTPError as http_err:
+        error_detail = response.json()
+        logger.error(f"{error_detail}")
+        raise ValueError(f"{error_detail.get('detail')}")
+    except requests.exceptions.RequestException as req_err:
+        logger.error(f"Request error occurred: {req_err}")
+        raise ValueError(f"Error during file download: {req_err}")
+    except Exception as e:
+        logger.error(f"Error during API request: {e}")
+        raise ValueError(f"Something went wrong. Check the logs for details.")
+
+def send_evaluation_request(model_type, model_name, dimension, generations, job_name, deployment_type, token):
+    endpoint = "evaluations/"
+    data = {
+        "model_type": model_type,
+        "model_name": model_name,
+        "dimensions": dimension,
+        "generations": generations,
+        "job_name": job_name,
+        "dType": deployment_type
+    }
+    if token != "":
+        data["token"] = token
+    return make_api_request(endpoint, method="post", data=data)
+
+def job_status_request(id):
+    endpoint = "evaluations/job_status"
+    params = {"uid": id}
+    return make_api_request(endpoint, params=params)
+
+def stop_job_request(id):
+    endpoint = "evaluations/stop"
+    params = {"uid": id}
+    return make_api_request(endpoint, method="post", params=params)
+
+def stop_all_job_request():
+    endpoint = "evaluations/stopall"
+    return make_api_request(endpoint, method="post")
+
+def delete_job_request(id):
+    endpoint = "evaluations/remove"
+    params = {"uid": id}
+    return make_api_request(endpoint, method="post", params=params)
+
+def download_report_request(file_id):
+    try:
+        download_url = f"{VIGIL_API_BASE_URL}/evaluations/download_file?file_id={file_id}"
+        response = requests.get(download_url)
+        response.raise_for_status()
+
+        filename = response.headers.get('Content-Disposition', '').split('filename=')[1].strip('"')
+
+        with open(filename, 'wb') as file:
+            file.write(response.content)
+
+        return f"File downloaded successfully: {filename}"
+
+    except requests.exceptions.HTTPError as http_err:
+        error_detail = response.json()
+        logger.error(f"{error_detail}")
+        raise ValueError(f"{error_detail.get('detail')}")
+    except requests.exceptions.RequestException as req_err:
+        logger.error(f"Request error occurred: {req_err}")
+        raise ValueError(f"Error during file download: {req_err}")
+
+def list_job_request():
+    endpoint = "jobs/"
+    return make_api_request(endpoint)
+
+def get_job_detail_request(id):
+    endpoint = "jobs/detail"
+    params = {"job_id": id}
+    return make_api_request(endpoint, params=params)
+
+def model_token_request(source, name, token, isPrimary):
+    endpoint = f"integrations/"
+    data = {
+        "token": token,
+        "name": name,
+        "type": source,
+        "isPrimary": isPrimary
+    }
+    return make_api_request(endpoint, method="post", data=data)
+
+def get_model_token_request():
+    endpoint = "integrations/"
+    return make_api_request(endpoint)
+
+def check_jobs_progress(id):
+    endpoint = "evaluations/job_progress"
+    params = {"uid": id}
+    return make_api_request(endpoint, method="get", params=params)

vijil-0.1.16/vijil/vijilapi/backup_api_handler.py

@@ -0,0 +1,211 @@
+# api_handler.py
+import requests
+import logging
+
+from .config_handler import load_config
+
+VIGIL_API_BASE_URL = "http://127.0.0.1:8000/api/v1"
+# VIGIL_API_BASE_URL = "http://dockder-test-alb-2018306447.us-west-2.elb.amazonaws.com/api/v1"
+
+# Set up logging
+logging.basicConfig(level=logging.ERROR, filename='vijil.log', filemode='w',
+                    format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+
+
+def custom_headers():
+    """Customize headers for display."""
+    return {
+        "job_id": "Job ID",
+        "task_id": "ID",
+        "model_type": "Model Type",
+        "model_name": "Model Name",
+        "probe_group": "Probe Group",
+        "status": "Status",
+        "job_result": "Result",
+        "start_time": "Start Time",
+        "end_time": "End Time",
+    }
+
+def send_evaluation_request(model_type, model_name, probes, generations):
+    url = f"{VIGIL_API_BASE_URL}/evaluations/"
+    username, token = load_config()
+
+    if not username or not token:
+        raise ValueError("Username or token not found in configuration.")
+
+    headers = {
+        # "Authorization": f"Bearer {token}",
+        "username": username,
+        "clitoken": token,
+    }
+
+    data = {
+        "model_type": model_type,
+        "model_name": model_name,
+        "probes": probes,
+        "generations": generations,
+    }
+
+    try:
+        response = requests.post(url, json=data, headers=headers)
+        response.raise_for_status()
+        return response.json()
+
+    except Exception as e:
+        logger.error(f"Error during API request: {e}")
+        raise ValueError("An error occurred during the API request. Check the logs for details.")
+
+
+def job_status_request(id):
+    url = f"{VIGIL_API_BASE_URL}/evaluations/job_status"
+    username, token = load_config()
+
+    if not username or not token:
+        raise ValueError("Username or token not found in configuration.")
+
+    headers = {
+        "username": username,
+        "clitoken": token,
+    }
+    params = {"task_id": id}
+    try:
+        response = requests.get(url, params=params, headers=headers)
+        response.raise_for_status()
+        return response.json()
+
+    except Exception as e:
+        logger.error(f"Error during API request: {e}")
+        raise ValueError("An error occurred during the API request. Check the logs for details.")
+    
+def stop_job_request(id):
+    url = f"{VIGIL_API_BASE_URL}/evaluations/stop"
+    username, token = load_config()
+
+    if not username or not token:
+        raise ValueError("Username or token not found in configuration.")
+
+    headers = {
+        "username": username,
+        "clitoken": token,
+    }
+    params = {"task_id": id}
+    try:
+        response = requests.post(url, params=params, headers=headers)
+        response.raise_for_status()
+        return response.json()
+
+    except Exception as e:
+        logger.error(f"Error during API request: {e}")
+        raise ValueError("An error occurred during the API request. Check the logs for details.")
+    
+def stop_all_job_request():
+    url = f"{VIGIL_API_BASE_URL}/evaluations/stopall"
+    username, token = load_config()
+
+    if not username or not token:
+        raise ValueError("Username or token not found in configuration.")
+
+    headers = {
+        "username": username,
+        "clitoken": token,
+    }
+
+    try:
+        response = requests.post(url, headers=headers)
+        response.raise_for_status()
+        return response.json()
+
+    except Exception as e:
+        logger.error(f"Error during API request: {e}")
+        raise ValueError("An error occurred during the API request. Check the logs for details.")
+    
+def delete_job_request(id):
+    url = f"{VIGIL_API_BASE_URL}/evaluations/remove"
+    username, token = load_config()
+
+    if not username or not token:
+        raise ValueError("Username or token not found in configuration.")
+
+    headers = {
+        "username": username,
+        "clitoken": token,
+    }
+    params = {"task_id": id}
+    try:
+        response = requests.post(url, params=params, headers=headers)
+        response.raise_for_status()
+        return response.json()
+
+    except Exception as e:
+        logger.error(f"Error during API request: {e.detail}")
+        raise ValueError("An error occurred during the API request. Check the logs for details.")
+    
+def download_report_request(file_id):
+
+    try:
+        download_url = f"{VIGIL_API_BASE_URL}/evaluations/download_file?file_id={file_id}"
+        response = requests.get(download_url)
+        response.raise_for_status()
+
+        filename = response.headers.get('Content-Disposition', '').split('filename=')[1].strip('"')
+
+        with open(filename, 'wb') as file:
+            file.write(response.content)
+
+        return f"File downloaded successfully: {filename}"
+
+    except requests.exceptions.RequestException as e:
+        raise ValueError(f"Error during file download: {e}")
+    
+def list_job_request():
+
+    jobs_url = f"{VIGIL_API_BASE_URL}/jobs/"
+    try:
+        username, token = load_config()
+
+        if not username or not token:
+            raise ValueError("Username or token not found in configuration.")
+
+        headers = {
+            "username": username,
+            "clitoken": token,
+        }
+
+        response = requests.get(jobs_url, headers=headers)
+        response.raise_for_status()
+        jobs_data = response.json()
+
+        if not jobs_data:
+            return {
+                "message": "No jobs found."
+            }
+
+        return {
+            "table_data":jobs_data
+        }
+    
+    except requests.exceptions.RequestException as e:
+        raise ValueError(f"Error fetching jobs: {e}")
+    
+def get_job_detail_request(id):
+    url = f"{VIGIL_API_BASE_URL}/jobs/detail"
+    username, token = load_config()
+
+    if not username or not token:
+        raise ValueError("Username or token not found in configuration.")
+
+    headers = {
+        "username": username,
+        "clitoken": token,
+    }
+    params = {"job_id": id}
+    try:
+        response = requests.get(url, params=params, headers=headers)
+        response.raise_for_status()
+        return response.json()
+
+    except Exception as e:
+        logger.error(f"Error during API request: {e}")
+        raise ValueError("An error occurred during the API request. Check the logs for details.")

vijil-0.1.16/vijil/vijilapi/config_handler.py

@@ -0,0 +1,34 @@
+import os
+import json
+from datetime import datetime, timedelta
+
+HIDDEN_DIR_NAME = ".vijil"
+CONFIG_FILE_NAME = "vijil_config.json"
+CONFIG_FILE_PATH = os.path.join(os.path.expanduser('~'), HIDDEN_DIR_NAME, CONFIG_FILE_NAME)
+
+def save_config(username, token):
+    config_data = {"username": username, "token": token, "timestamp": datetime.utcnow().isoformat()}
+    os.makedirs(os.path.dirname(CONFIG_FILE_PATH), exist_ok=True)
+    with open(CONFIG_FILE_PATH, 'w') as config_file:
+        json.dump(config_data, config_file)
+
+def load_config():
+    try:
+        with open(CONFIG_FILE_PATH, 'r') as config_file:
+            config_data = json.load(config_file)
+            timestamp = datetime.fromisoformat(config_data.get("timestamp"))
+            expiration_time = timestamp + timedelta(days=2)
+            if datetime.utcnow() <= expiration_time:
+                return config_data.get("username"), config_data.get("token")
+            else:
+                remove_config()
+                return None, None
+    except (FileNotFoundError, json.JSONDecodeError, KeyError):
+        return None, None
+
+def remove_config():
+    try:
+        os.remove(CONFIG_FILE_PATH)
+        return None
+    except FileNotFoundError:
+        pass