Upload 10 files

README.md

@@ -0,0 +1,202 @@
+---
+library_name: peft
+base_model: meta-llama/Meta-Llama-3-8B
+---
+
+# Model Card for Model ID
+
+<!-- Provide a quick summary of what the model is/does. -->
+
+
+
+## Model Details
+
+### Model Description
+
+<!-- Provide a longer summary of what this model is. -->
+
+
+
+- **Developed by:** [More Information Needed]
+- **Funded by [optional]:** [More Information Needed]
+- **Shared by [optional]:** [More Information Needed]
+- **Model type:** [More Information Needed]
+- **Language(s) (NLP):** [More Information Needed]
+- **License:** [More Information Needed]
+- **Finetuned from model [optional]:** [More Information Needed]
+
+### Model Sources [optional]
+
+<!-- Provide the basic links for the model. -->
+
+- **Repository:** [More Information Needed]
+- **Paper [optional]:** [More Information Needed]
+- **Demo [optional]:** [More Information Needed]
+
+## Uses
+
+<!-- Address questions around how the model is intended to be used, including the foreseeable users of the model and those affected by the model. -->
+
+### Direct Use
+
+<!-- This section is for the model use without fine-tuning or plugging into a larger ecosystem/app. -->
+
+[More Information Needed]
+
+### Downstream Use [optional]
+
+<!-- This section is for the model use when fine-tuned for a task, or when plugged into a larger ecosystem/app -->
+
+[More Information Needed]
+
+### Out-of-Scope Use
+
+<!-- This section addresses misuse, malicious use, and uses that the model will not work well for. -->
+
+[More Information Needed]
+
+## Bias, Risks, and Limitations
+
+<!-- This section is meant to convey both technical and sociotechnical limitations. -->
+
+[More Information Needed]
+
+### Recommendations
+
+<!-- This section is meant to convey recommendations with respect to the bias, risk, and technical limitations. -->
+
+Users (both direct and downstream) should be made aware of the risks, biases and limitations of the model. More information needed for further recommendations.
+
+## How to Get Started with the Model
+
+Use the code below to get started with the model.
+
+[More Information Needed]
+
+## Training Details
+
+### Training Data
+
+<!-- This should link to a Dataset Card, perhaps with a short stub of information on what the training data is all about as well as documentation related to data pre-processing or additional filtering. -->
+
+[More Information Needed]
+
+### Training Procedure
+
+<!-- This relates heavily to the Technical Specifications. Content here should link to that section when it is relevant to the training procedure. -->
+
+#### Preprocessing [optional]
+
+[More Information Needed]
+
+
+#### Training Hyperparameters
+
+- **Training regime:** [More Information Needed] <!--fp32, fp16 mixed precision, bf16 mixed precision, bf16 non-mixed precision, fp16 non-mixed precision, fp8 mixed precision -->
+
+#### Speeds, Sizes, Times [optional]
+
+<!-- This section provides information about throughput, start/end time, checkpoint size if relevant, etc. -->
+
+[More Information Needed]
+
+## Evaluation
+
+<!-- This section describes the evaluation protocols and provides the results. -->
+
+### Testing Data, Factors & Metrics
+
+#### Testing Data
+
+<!-- This should link to a Dataset Card if possible. -->
+
+[More Information Needed]
+
+#### Factors
+
+<!-- These are the things the evaluation is disaggregating by, e.g., subpopulations or domains. -->
+
+[More Information Needed]
+
+#### Metrics
+
+<!-- These are the evaluation metrics being used, ideally with a description of why. -->
+
+[More Information Needed]
+
+### Results
+
+[More Information Needed]
+
+#### Summary
+
+
+
+## Model Examination [optional]
+
+<!-- Relevant interpretability work for the model goes here -->
+
+[More Information Needed]
+
+## Environmental Impact
+
+<!-- Total emissions (in grams of CO2eq) and additional considerations, such as electricity usage, go here. Edit the suggested text below accordingly -->
+
+Carbon emissions can be estimated using the [Machine Learning Impact calculator](https://mlco2.github.io/impact#compute) presented in [Lacoste et al. (2019)](https://arxiv.org/abs/1910.09700).
+
+- **Hardware Type:** [More Information Needed]
+- **Hours used:** [More Information Needed]
+- **Cloud Provider:** [More Information Needed]
+- **Compute Region:** [More Information Needed]
+- **Carbon Emitted:** [More Information Needed]
+
+## Technical Specifications [optional]
+
+### Model Architecture and Objective
+
+[More Information Needed]
+
+### Compute Infrastructure
+
+[More Information Needed]
+
+#### Hardware
+
+[More Information Needed]
+
+#### Software
+
+[More Information Needed]
+
+## Citation [optional]
+
+<!-- If there is a paper or blog post introducing the model, the APA and Bibtex information for that should go in this section. -->
+
+**BibTeX:**
+
+[More Information Needed]
+
+**APA:**
+
+[More Information Needed]
+
+## Glossary [optional]
+
+<!-- If relevant, include terms and calculations in this section that can help readers understand the model or model card. -->
+
+[More Information Needed]
+
+## More Information [optional]
+
+[More Information Needed]
+
+## Model Card Authors [optional]
+
+[More Information Needed]
+
+## Model Card Contact
+
+[More Information Needed]
+### Framework versions
+
+- PEFT 0.7.1

adapter_config.json

@@ -0,0 +1,31 @@
+{
+  "alpha_pattern": {},
+  "auto_mapping": null,
+  "base_model_name_or_path": "meta-llama/Meta-Llama-3-8B",
+  "bias": "none",
+  "fan_in_fan_out": false,
+  "inference_mode": true,
+  "init_lora_weights": true,
+  "layers_pattern": null,
+  "layers_to_transform": null,
+  "loftq_config": {},
+  "lora_alpha": 32,
+  "lora_dropout": 0.05,
+  "megatron_config": null,
+  "megatron_core": "megatron.core",
+  "modules_to_save": null,
+  "peft_type": "LORA",
+  "r": 16,
+  "rank_pattern": {},
+  "revision": null,
+  "target_modules": [
+    "q_proj",
+    "down_proj",
+    "o_proj",
+    "up_proj",
+    "v_proj",
+    "gate_proj",
+    "k_proj"
+  ],
+  "task_type": "CAUSAL_LM"
+}

adapter_model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d8d134a867b464adc856b5f01dae0941f27ca474c7bdcd6b470e8782aeec34bb
+size 167832240

optimizer.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1f9798326b30a27d4062af95ef5bf8e6a24796485534d0476d7c00581201d073
+size 84581014

rng_state.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:50b38bb265826e4d13d27ecc837b01eb2f65ab2f5d4618ee7ec8f8d5f71f00a6
+size 14244

scheduler.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fe0caad89d6eb6d8e004bec75a300cce2acf1f6087f850d287d64723309dd1d2
+size 1064

test.csv

@@ -0,0 +1,574 @@
+Endpoint,Description,Inputs,Output,Test_Code
+/config/rest/delete/,requesting to delete the config values when provided valid config name but with invalid token,"config_value = { ""name"": ""primary_server"" }","{
+    ""status"": 401,
+    ""message"": ""Invalid token""
+}
+","def test_config_delete_with_invalid_token(invalid_exec_api):
+    """"""
+    deleting the non deletable config values with invalid token
+    """"""
+    config_value = {
+        ""name"": ""primary_server"",
+    }
+    r = invalid_exec_api.config_delete(config_value)
+    test_assert.status(r, 401)
+    result = r.json()
+    assert result['detail'] == ""Invalid token.""
+"
+/config/rest/version/,Fetching the information when invalid token is provided,,"{
+""status"":401,
+""message"":""invalid token""
+}","def test_version_config_with_invalid_token(invalid_exec_api):
+    """"""
+    Fetching the information of Version and Build Number with invalid token
+    """"""
+    r = invalid_exec_api.config_version()
+    result = r.json()
+    test_assert.status(r, 401)
+    assert result['detail'] == ""Invalid token."""
+"/deploy/rest/delete/{UUID}/
+
+","the manager deletes the image when the manager has rights over the user and the server
+",,"{
+""status"":204
+}","endpoint = ""deploy_delete""
+
+PARAMETERS = [{""dest_obj"": OBJ_DEPL}]
+PARAMETERS_SRV_RIGHT = [{""dest_obj"": OBJ_DEPL, ""deploy_with"": SRV_MANAGER_RIGHTS}]
+PARAMETERS_NO_SRV_RIGHT = [{""dest_obj"": OBJ_DEPL, ""deploy_with"": SRV_NO_MANAGER_RIGHTS}]
+
+@pytest.mark.parametrize(""custom_lib_non_admin_operations"", PARAMETERS_SRV_RIGHT, indirect=True)
+@pytest.mark.parametrize(""custom_lib_admin_operations"", PARAMETERS_SRV_RIGHT, indirect=True)
+
+def test_deploy_delete_manager_server_right(skip_if_not_manager, custom_lib_admin_operations, custom_lib_non_admin_operations, run_api):
+    """"""
+    Deleting the VM by Manager
+    """"""
+    # When the user is not part of the group that the manager manages and deployment is on manager rights to server
+    deploy_id = custom_lib_admin_operations
+    r = run_api.deploy_image_delete(deploy_id, {})
+    test_assert.status(r, manager_rights_response(endpoint, manages_user=False, manages_server=True))
+
+    # When the user is part of the group that the manager manages and deployment is on manager rights to server
+    deploy_id = custom_lib_non_admin_operations
+    r = run_api.deploy_image_delete(deploy_id, {})
+    test_assert.status(r, manager_rights_response(endpoint, manages_user=True, manages_server=True))"
+/deploy/rest/shutdown/{{UUID}}/,shutting down the deployment of machine by an admin using valid UUID and machine is in running state,,"{
+""status"" : 201, 
+""response"" : Machine shutdown
+}","PARAMETERS = [{""dest_obj"": OBJ_DEPL, ""final_state"": DEPL_STATE[""running""]}]
+
+@pytest.mark.parametrize(""custom_lib_non_admin_operations"", PARAMETERS, indirect=True)
+def test_deploy_shutdown_admin(skip_if_not_admin, custom_lib_non_admin_operations, run_api):
+    """"""
+    shutdown the VM by Admin
+    """"""
+    deploy_id = custom_lib_non_admin_operations
+    r = run_api.deploy_shutdown(deploy_id)
+    test_assert.status(r, 201)
+
+"
+/deploy/rest/stop/{{UUID}}/,stopping a machine by an admin when valid UUID is provided and machine is in running state,,"{
+""status"" : 201,
+""response""  : stopping deployment
+}","endpoint = ""deploy_stop""
+
+PARAMETERS = [{""dest_obj"": OBJ_DEPL, ""final_state"": DEPL_STATE[""running""]}]
+PARAMETERS_SRV_RIGHT = [{""dest_obj"": OBJ_DEPL, ""final_state"": DEPL_STATE[""running""], ""deploy_with"": SRV_MANAGER_RIGHTS}]
+PARAMETERS_NO_SRV_RIGHT = [{""dest_obj"": OBJ_DEPL, ""final_state"": DEPL_STATE[""running""], ""deploy_with"": SRV_NO_MANAGER_RIGHTS}]
+
+@pytest.mark.parametrize(""custom_lib_non_admin_operations"", PARAMETERS, indirect=True)
+def test_deploy_stop_admin(skip_if_not_admin, custom_lib_non_admin_operations, run_api):
+    """"""
+    Rebooting the VM by Admin
+    """"""
+    # Admin check of Starting a deployment created by different user
+    deploy_id = custom_lib_non_admin_operations
+    r = run_api.deploy_stop(deploy_id)
+    test_assert.status(r, 201)
+"
+/deploy/rest/stop/{{UUID}}/,stopping a machine by non-admin user when valid UUID is provided and machine is in running state,,"{
+""status"" : 403
+}","endpoint = ""deploy_stop""
+
+PARAMETERS = [{""dest_obj"": OBJ_DEPL, ""final_state"": DEPL_STATE[""running""]}]
+PARAMETERS_SRV_RIGHT = [{""dest_obj"": OBJ_DEPL, ""final_state"": DEPL_STATE[""running""], ""deploy_with"": SRV_MANAGER_RIGHTS}]
+PARAMETERS_NO_SRV_RIGHT = [{""dest_obj"": OBJ_DEPL, ""final_state"": DEPL_STATE[""running""], ""deploy_with"": SRV_NO_MANAGER_RIGHTS}]
+
+@pytest.mark.parametrize(""custom_lib_admin_operations"", PARAMETERS, indirect=True)
+def test_deploy_stop_non_admin(skip_if_not_non_admin, custom_lib_admin_operations, run_api):
+    """"""
+    stopping the VM by non-admin
+    """"""
+    deploy_id = custom_lib_admin_operations
+    r = run_api.deploy_stop(deploy_id)
+    test_assert.status(r, 403)
+"
+/deploy/rest/stop/{{UUID}}/,"stopping a machine deployment by a manager when valid UUID is provided and machine is in running state , and manager has rights over servers",,,"endpoint = ""deploy_stop""
+
+PARAMETERS = [{""dest_obj"": OBJ_DEPL, ""final_state"": DEPL_STATE[""running""]}]
+PARAMETERS_SRV_RIGHT = [{""dest_obj"": OBJ_DEPL, ""final_state"": DEPL_STATE[""running""], ""deploy_with"": SRV_MANAGER_RIGHTS}]
+PARAMETERS_NO_SRV_RIGHT = [{""dest_obj"": OBJ_DEPL, ""final_state"": DEPL_STATE[""running""], ""deploy_with"": SRV_NO_MANAGER_RIGHTS}]
+
+@pytest.mark.parametrize(""custom_lib_non_admin_operations"", PARAMETERS_SRV_RIGHT, indirect=True)
+@pytest.mark.parametrize(""custom_lib_admin_operations"", PARAMETERS_SRV_RIGHT, indirect=True)
+def test_deploy_stop_manager_server_right(skip_if_not_manager, custom_lib_admin_operations, custom_lib_non_admin_operations, run_api):
+    """"""
+    stopping the VM by manager when have right on server
+    """"""
+    # When the user is not part of the group that the manager manages
+    deploy_id = custom_lib_admin_operations
+    r = run_api.deploy_stop(deploy_id)
+    test_assert.status(r, manager_rights_response(endpoint, manages_user=False, manages_server=True))
+
+    # When the user is part of the group that the manager manages and deployment is on manager rights to server
+    deploy_id = custom_lib_non_admin_operations
+    r = run_api.deploy_stop(deploy_id)
+    test_assert.status(r, manager_rights_response(endpoint, manages_user=True, manages_server=True))
+    run_api.deploy_stop(deploy_id)
+
+"
+/deploy/rest/stop/{{UUID}}/,"stopping a machine deployment by a manager when valid UUID is provided and machine is in running state , but manager do not have rights over servers",,,"endpoint = ""deploy_stop""
+
+PARAMETERS = [{""dest_obj"": OBJ_DEPL, ""final_state"": DEPL_STATE[""running""]}]
+PARAMETERS_SRV_RIGHT = [{""dest_obj"": OBJ_DEPL, ""final_state"": DEPL_STATE[""running""], ""deploy_with"": SRV_MANAGER_RIGHTS}]
+PARAMETERS_NO_SRV_RIGHT = [{""dest_obj"": OBJ_DEPL, ""final_state"": DEPL_STATE[""running""], ""deploy_with"": SRV_NO_MANAGER_RIGHTS}]
+
+@pytest.mark.parametrize(""custom_lib_non_admin_operations"", PARAMETERS_NO_SRV_RIGHT, indirect=True)
+@pytest.mark.parametrize(""custom_lib_admin_operations"", PARAMETERS_NO_SRV_RIGHT, indirect=True)
+def test_deploy_stop_manager_no_server_right(skip_if_not_manager, custom_lib_admin_operations, custom_lib_non_admin_operations, run_api):
+    """"""
+    stopping the VM by manager when have no right on server
+    """"""
+    # When the user is not part of the group that the manager manages and the deployment is not on manager rightful server
+    deploy_id = custom_lib_admin_operations
+    r = run_api.deploy_stop(deploy_id)
+    test_assert.status(r, manager_rights_response(endpoint, manages_user=False, manages_server=False))
+
+    # When the user is part of the group that the manager manages but the deployment is not on manager rightful server
+    deploy_id = custom_lib_non_admin_operations
+    r = run_api.deploy_stop(deploy_id)
+    test_assert.status(r, manager_rights_response(endpoint, manages_user=True, manages_server=False))
+
+"
+/ilibrary/rest/add/,creating an island library and adding it using invalid IPs,"{
+        ""name"": ""test_ilibrary_add_invalid_ips"",
+        ""is_public"": True,
+        ""network_segments"": {
+            ""add"": [
+                {
+                    ""name"": ""network_segment"",
+                    ""bridge_ip"": ""1921681000"",
+                    ""start_ip"": ""1921681001"",
+                    ""end_ip"": ""192168100150""
+                }
+            ]
+        }
+    }","{
+""status"" : 400,
+""message"" : ""Enter valid IPv4 addresses""
+}","
+def test_ilibrary_add_invalid_ips(run_api):
+    """"""
+    Creating an Island Library with invalid bridge ip, start ip, end ip
+    """"""
+    params = {
+        ""name"": ""test_ilibrary_add_invalid_ips"",
+        ""is_public"": True,
+        ""network_segments"": {
+            ""add"": [
+                {
+                    ""name"": ""network_segment"",
+                    ""bridge_ip"": ""1921681000"",
+                    ""start_ip"": ""1921681001"",
+                    ""end_ip"": ""192168100150""
+                }
+            ]
+        }
+    }
+    params, r = run_api.ilibrary_add_new_island(params=params)
+    test_assert.status(r, 400)
+    rjson = r.json()
+    errors = rjson['network_segments']['add'][0]
+    assert errors['start_ip'] == ['Enter a valid IPv4 address.']
+    assert errors['end_ip'] == ['Enter a valid IPv4 address.']
+    assert errors['bridge_ip'] == ['Enter a valid IPv4 address.']
+"
+/ilibrary/rest/details/{UUID}/,fetching details of public island library from private island,"machine1 = {
+        ""uuid"": r1.json()[""uuid""],
+        ""nics"": {
+            ""add"": [
+                {
+                    ""mac"": ""auto"",
+                    ""type"": ""bridge"",
+                    ""model"": networks[0].get(""model"", ""virtio""),
+                    ""segment"": ""Default Public Segment""
+                },
+
+            ],
+        }
+
+    }
+    params = {
+        ""name"": ""Machine1"",
+        ""is_public"": False,
+        ""machines"": {
+            ""add"": [machine1],
+        },
+    }","{
+    ""response"" : success
+}","def test_ilibrary_details_with_edit_private_island_to_public_island(skip_if_not_admin, run_api):
+    """"""
+       To check machine type with public island
+    """"""
+    params1, r1 = run_api.library_add_new_vm(networks=networks)
+    machine1 = {
+        ""uuid"": r1.json()[""uuid""],
+        ""nics"": {
+            ""add"": [
+                {
+                    ""mac"": ""auto"",
+                    ""type"": ""bridge"",
+                    ""model"": networks[0].get(""model"", ""virtio""),
+                    ""segment"": ""Default Public Segment""
+                },
+
+            ],
+        }
+
+    }
+    params = {
+        ""name"": ""Machine1"",
+        ""is_public"": False,
+        ""machines"": {
+            ""add"": [machine1],
+        },
+    }
+    params, r = run_api.ilibrary_add_new_island(params=params)
+    island_id = r.json()[""uuid""]
+    params, r = run_api.ilibrary_edit_island(uuid=island_id, params={""is_public"": True})
+    res = r.json()[""machines""]
+    run_api.ilibrary_delete(uuid=island_id)
+    run_api.library_delete(r1.json()[""uuid""])
+    for machine in res:
+        if not machine[""is_public""]:
+            assert False, ""The json is %s"" % r.json()
+
+"
+/library/rest/add,adding vm to library when multiple boot disks and same order is passed,"disks = [{ ""size"": 20, ""port"": ""sdb"", ""type"": ""sata"", ""format"": ""qcow2"", ""is_boot"": True, ""boot_order"": 1 }, { ""size"": 20, ""port"": ""sda"", ""type"": ""sata"", ""format"": ""qcow2"", ""is_boot"": True, ""boot_order"": 1 }]","{
+""status"" : 400,
+""response"" : Bad request
+}","def test_add_vm_to_library_multiple_bootable_disk_with_same_boot_order(run_api):
+    """"""
+    If multiple bootable cds with same boot order is passed
+    """"""
+
+    disks = [{
+        ""size"": 20,
+        ""port"": ""sdb"",
+        ""type"": ""sata"",
+        ""format"": ""qcow2"",
+        ""is_boot"": True,
+        ""boot_order"": 1
+    },
+        {
+            ""size"": 20,
+            ""port"": ""sda"",
+            ""type"": ""sata"",
+            ""format"": ""qcow2"",
+            ""is_boot"": True,
+            ""boot_order"": 1
+    }]
+
+    params, response = run_api.library_add_new_vm(disks=disks, noraise=True)
+    test_assert.status(response, 400)
+"
+/library/rest/adddisk/{{UUID}}/ ,adding disk to library when provided lib_UUID that does not exist,"lib_UUID = ""doesnotexist""","{
+""status"" : 404
+}","def test_lib_add_disk_with_invalid_UUID(run_api):
+    lib_UUID = ""doesnotexist""
+    r = run_api.library_add_disk(lib_UUID)
+    test_assert.status(r, 404)
+"
+/library/rest/ctypes/,getting the console type when requested,,"{
+""status"" : 200,
+""response"" :  console type details displayed
+}","def test_library_ctypes(run_api):
+    """"""
+    Getting the list of console type
+    """"""
+    r = run_api.library_console_types()
+    result = r.json()
+    test_assert.status(result, LIBRARY_CONSOLE_TYPE, ""library_ctypes"")
+    test_assert.status(r, 200)
+"
+/library/rest/delete/{UUID}/,deleting a library by non-admin when provided with valid UUID,,"{
+""status"" : 403
+}","PARAMETERS = [{""dest_obj"": OBJ_LIB}]
+
+@pytest.mark.parametrize(""custom_lib_admin_operations"", PARAMETERS, indirect=True)
+def test_lib_delete_non_admin(skip_if_not_non_admin, custom_lib_admin_operations, run_api):
+    """"""
+    Deleting the Library by non-Admin
+    """"""
+    # Non-admin check for deleting the Library created by different user.
+    lib_id = custom_lib_admin_operations
+    r = run_api.library_delete(lib_id, {})
+    test_assert.status(r, 403)
+
+"
+/library/rest/edit/{UUID}/,deletion of disk when invalid UUID provided,"{""delete"": [
+        {
+            ""UUID"": disk_UUID,
+            ""port"": ""sdz"",
+            ""type"": r['hw']['disks'][0]['type']
+        }
+    ]
+    }","{
+""status"" : 404,
+""message"" :  ""Disk with UUID does not exist""
+}","def test_library_edit_delete_invalid_disk_UUID(library_add_new_vm, run_api):
+    """"""
+    delete disk with invalid UUID
+    """"""
+    p, r = library_add_new_vm
+    lib_id = r['UUID']
+    disk_UUID = str(UUID.UUID4())
+    disk_UUID = 'invalid'
+    disks = {""delete"": [
+        {
+            ""UUID"": disk_UUID,
+            ""port"": ""sdz"",
+            ""type"": r['hw']['disks'][0]['type']
+        }
+    ]
+    }
+    params = {""hw"": {""disks"": disks}}
+    res = run_api.library_edit(lib_id, params)
+    test_assert.status(res, 404)
+    rjson = res.json()
+    assert rjson['error'] == f""Disk with UUID {disk_UUID} does not exist"", ""|> json %s"" % rjson
+"
+/library/rest/edit/{UUID}/,updation of library when is_public flag set to True,"params = { ""is_public"": True, ""hw"": {} }","{
+""status"" : 400,
+""message"" : ""Failed to create task to sync public layers on primary""
+}","def test_library_edit_update_is_public_flag(skip_if_not_non_admin, library_add_new_vm, run_api):
+    """"""
+    Update is_public flag
+    """"""
+    p, res = library_add_new_vm
+    UUID = res['UUID']
+    params = {
+        ""is_public"": True,
+        ""hw"": {}
+    }
+    r = run_api.library_edit(UUID, params)
+    test_assert.status(r, 400)
+    rjson = r.json()
+    assert rjson['error'] == ""Failed to create task to sync public layers on primary"", ""Json |> %s"" % rjson
+"
+/library/rest/edit/{UUID}/,updation of network in a library with valid data,"networks = [{
+        ""type"": ""bridge"",
+        ""model"": ""virtio"",
+        ""segment"": ""Default Public Segment"",
+    }
+    ]
+
+update_network = [{
+        ""type"": ""host"",
+        ""model"": ""virtio"",
+        ""segment"": ""HostOnly Segment"",
+    }]
+
+","{
+""status"" : 201
+}","def test_library_edit_network_with_valid_data(run_api):
+    """"""
+    edit network with valid data
+    """"""
+    networks = [{
+        ""type"": ""bridge"",
+        ""model"": ""virtio"",
+        ""segment"": ""Default Public Segment"",
+    }
+    ]
+    params, r = run_api.library_add_new_vm(networks=networks)
+    update_netork = [{
+        ""type"": ""host"",
+        ""model"": ""virtio"",
+        ""segment"": ""HostOnly Segment"",
+    }]
+    params = {'hw': {'networks': update_netork}}
+    lib_id = r.json()[""UUID""]
+    res = run_api.library_edit(lib_id, params)
+    test_assert.status(res, 201)
+    rjson = res.json()
+    new_network = rjson['hw']['networks'][0]
+    assert new_network['type'] == 'host', ""|> Error %s"" % rjson
+    assert new_network['segment'] == 'HostOnly Segment', ""|> Error %s"" % rjson
+    run_api.library_delete(lib_id, {})
+"
+​/library​/rest​/hvmtypes​/,fetching the hypervisor type when requested,,"{
+""status"" : 200,
+""response"" : list of hypervisor type
+}","def test_library_hvmtypes(run_api):
+    """"""
+    Getting the list of Hypervisor type
+    """"""
+    r = run_api.library_hvmtypes()
+    result = r.json()
+    test_assert.status(result, LIBRARY_HVM_TYPE, ""library_hvmtypes"")
+    test_assert.status(r, 200)
+"
+/library/rest/revisions/,requesting the revision list of library when machine_UUID is empty,"{
+machine_UUID : ''
+}","{
+""status"" : 400,
+""message"" : ""Machine UUID should be provided""}","def test_library_revisions_without_UUID(run_api):
+    """"""
+    Without UUID
+    """"""
+    res = run_api.library_revisions("""")
+    test_assert.status(res, 400)
+    rjson = res.json()
+    assert rjson['detail'] == ""Machine UUID should be provided"", ""|> The error %s"" % rjson
+"
+​/rtask​/rest​/rlist​/,fetching the list of remote tasks without authorization,,"{
+""status"" : 401,
+""message"" : ""Authentication credentials were not provided""
+}","def test_rtask_rlist_without_authorization(anonymous_exec_api):
+    """"""
+    Fetching the List of Jobs without authorization
+    """"""
+    r = anonymous_exec_api.rtask_rlist()
+    res = r.json()
+    test_assert.status(r, 401)
+    assert res['detail'] == ""Authentication credentials were not provided.""
+"
+ideploy/rest/change_ownership,Successful change of ownership from one user to another where both users exist and the requester has the necessary permissions.,"{
+        ""deployment_UUIDs"": [UUID],
+        ""owner"": ,
+        ""dest_user"": ""manager""
+}","{""status"": 200, ""message"": ""Operation performed successfully without any error""}","def test_deploy_change_ownership(skip_if_non_admin, non_admin_exec_api, run_api):
+    """"""
+    To change ownership of deployed machine from non-admin user to manager by admin
+    """"""
+    params, r = non_admin_exec_api.library_add_new_vm()
+    lib_id = r.json()[""UUID""]
+    r = non_admin_exec_api.deploy_image(lib_id=lib_id, deploy_on=list(run_api.clm_my_servers.keys()))
+    UUID = r.json()['UUID']
+    params = {
+        ""deployment_UUIDs"": [UUID],
+        ""owner"": non_admin_exec_api.user,
+        ""dest_user"": ""manager""
+    }
+    res = run_api.deploy_change_ownership(params=params)
+    test_assert.status(res, 200)
+    new_owner = run_api.deploy_details(deploy_id=UUID).json()['owner']
+    assert new_owner == ""manager""
+    run_api.deploy_image_delete(deploy_id=UUID)
+    run_api.library_delete(UUID=lib_id)
+"
+"license/rest/licenses_check
+"," when day params is negative
+","{
+""days"" : -1
+}","{
+""status:200,
+""message"": ""Value of `days` cannot be negative""
+}","def test_license_check_when_day_is_negative(run_api):
+    """"""
+    license check when day is negative
+    """"""
+    r = run_api.license_check(days=-1)
+    rjson = r.json()
+    test_assert.status(r, 400)
+    assert rjson['error'] == ""Value of `days` cannot be negative"", ""The error %s"" % rjson"
+/deploy/rest/deploylist,"getting list of image of deployed machine by setting scope to ""my"". Check the user type before performing the operation, only admin user type have the permission to perform such operations.","{
+scope : ""my""
+}","{
+    ""response"" : success
+}","def test_deploy_list_filter_with_scope_my(run_api, admin_exec_api, library_add_new_vm):
+    """"""
+    filter deploy list using scope = my
+    """"""
+    params, r = library_add_new_vm
+    lib_id = r[""uuid""]
+    r = admin_exec_api.deploy_image(lib_id)
+    deploy_id = r.json()[""uuid""]
+    count = check_count_deploylist(run_api, deploy_id, params={'scope': 'my', 'uuid': deploy_id})
+
+    if run_api.user_type == USER_TYPE['non_admin'] or run_api.user_type == USER_TYPE['manager']:
+        assert count == 0
+    elif run_api.user_type == USER_TYPE['admin']:
+        assert count == 1
+
+    r = admin_exec_api.deploy_image_delete(deploy_id)
+"
+/config/rest/set/,"setting the None value to secret config. Check the user type before performing the operation, only admin user type have the permission to perform such operations.
+","{
+        ""name"": ""secret"",
+        ""value"": None
+}","{
+""status"" : 400,
+""response"" :  'Invalid secret_key Value' 
+}","def test_config_None_set_secret(run_api):
+    """"""
+    Set the secret-key config value as None
+    """"""
+    config_value = {
+        ""name"": ""secret"",
+        ""value"": None
+    }
+    r = run_api.config_set(config_value)
+    res = r.json()
+    if run_api.user_type in [USER_TYPE[""manager""], USER_TYPE[""non_admin""]]:
+        test_assert.status(r, 403)
+    elif run_api.user_type == USER_TYPE['admin']:
+        test_assert.status(r, 400)
+        assert res[""result""] == 'FAILURE'
+        assert 'Invalid secret_key Value' in res[""error""], res
+
+
+"
+/group/rest/add/,"adding new group when group name field is missing. Check the user type before performing the operation, only admin user type have the permission to perform such operations.
+",,"{
+""status"" : 400,
+""message"" : ""Group Name is required and it can not be blank""
+}","def test_add_group_with_group_name_field_missing(run_api):
+    """"""
+    Adding new Group with group name field missing
+    """"""
+    params, r = run_api.group_add(template={})
+    if run_api.user_type in [USER_TYPE[""non_admin""], USER_TYPE[""manager""]]:
+        test_assert.status(r, 403)
+    elif run_api.user_type == USER_TYPE[""admin""]:
+        result = r.json()
+        test_assert.status(r, 400)
+        assert result['error'] == ""Group Name is required and it can not be blank""
+
+"
+/group/rest/update/,"updating the deployment strategy of a group using an invalid value. Check the user type before performing the operation, only admin user type have the permission to perform such operations.
+","{
+        ""name"",
+        ""deployment_strategy"": 'invalid'
+    }","{
+    ""status"" : 400,
+    ""message"" : ""Invalid deployment_strategy""
+}","def test_group_update_invalid_deployment_strategy(skip_if_not_admin, group_add, run_api):
+    """"""
+    group update invalid deployment_strategy
+    """"""
+    params, r = group_add
+    rjson = r.json()
+    group_id = rjson['id']
+    group_param = {
+        ""name"": rjson['name'],
+        ""deployment_strategy"": 'invalid'
+    }
+    updated_param, r = run_api.group_update(group_id, group_param)
+    run_api.user_type == USER_TYPE[""admin""]
+    result = r.json()
+    test_assert.status(r, 400)
+    assert result['error'] == ""Invalid deployment_strategy"", ""|> Json %s"" % result
+"

trainer_state.json

@@ -0,0 +1,63 @@
+{
+  "best_metric": 0.08488664031028748,
+  "best_model_checkpoint": "/kaggle/working/trainer/checkpoint-354",
+  "epoch": 3.0,
+  "eval_steps": 500,
+  "global_step": 354,
+  "is_hyper_param_search": false,
+  "is_local_process_zero": true,
+  "is_world_process_zero": true,
+  "log_history": [
+    {
+      "epoch": 1.0,
+      "learning_rate": 4.388888888888889e-05,
+      "loss": 0.7966,
+      "step": 118
+    },
+    {
+      "epoch": 1.0,
+      "eval_loss": 0.14867298305034637,
+      "eval_runtime": 37.5027,
+      "eval_samples_per_second": 0.693,
+      "eval_steps_per_second": 0.347,
+      "step": 118
+    },
+    {
+      "epoch": 2.0,
+      "learning_rate": 3.2962962962962964e-05,
+      "loss": 0.105,
+      "step": 236
+    },
+    {
+      "epoch": 2.0,
+      "eval_loss": 0.10169088840484619,
+      "eval_runtime": 37.4736,
+      "eval_samples_per_second": 0.694,
+      "eval_steps_per_second": 0.347,
+      "step": 236
+    },
+    {
+      "epoch": 3.0,
+      "learning_rate": 2.2037037037037038e-05,
+      "loss": 0.073,
+      "step": 354
+    },
+    {
+      "epoch": 3.0,
+      "eval_loss": 0.08488664031028748,
+      "eval_runtime": 37.5454,
+      "eval_samples_per_second": 0.692,
+      "eval_steps_per_second": 0.346,
+      "step": 354
+    }
+  ],
+  "logging_steps": 500,
+  "max_steps": 590,
+  "num_input_tokens_seen": 0,
+  "num_train_epochs": 5,
+  "save_steps": 500,
+  "total_flos": 1.3117494532453171e+17,
+  "train_batch_size": 2,
+  "trial_name": null,
+  "trial_params": null
+}

training_args.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:05cd2b18a00bd366c2eb1651ba82f068e5dd0988fec2f9720ca54c19c676c666
+size 4728