query stringlengths 9 9.05k | document stringlengths 10 222k | negatives listlengths 19 20 | metadata dict |
|---|---|---|---|
Gets the ssh access from appliance [Arguments] | def fusion_api_get_ssh_access(self, uri=None, api=None, headers=None):
return self.sshaccess.get(uri=uri, api=api, headers=headers) | [
"def ssh_access(self) -> Optional[pulumi.Input[Union[str, 'AgentPoolSSHAccess']]]:\n return pulumi.get(self, \"ssh_access\")",
"def client_ssh_access(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"client_ssh_access\")",
"def web_ssh_access(self) -> Optional[pulumi.Input[str]]:\n... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Edits the ssh access for appliance [Arguments] | def fusion_api_edit_ssh_access(self, body, uri=None, api=None, headers=None):
return self.sshaccess.put(body=body, uri=uri, api=api, headers=headers) | [
"def do_setremoteroot(self, args):\n import urllib.request\n ip = args #das right, ghettostyles. caution to the wind. No error checkin. whatevs.\n url = \"http://\"+str(ip)+\"/cgi-bin/cmh/tech_ra.sh\"\n password = str(urllib.request.urlopen(url).read().decode(\"utf-8\").split(\"-\")[1].s... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Adds an enclosure to the appliance [Arguments] | def fusion_api_add_enclosure(self, body, api=None, headers=None):
return self.enclosure.add(body, api, headers) | [
"def addEnclosure(self, enclosure):\n self.enclosures.append(enclosure)",
"def addAnimalToEnclosure(self, animal, enclosureID):\n for e in self.enclosures:\n if(enclosureID == e.getID()):\n e.addAnimal(animal)",
"def add_appliance(itemcode, description, marketprice, renta... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Update an enclosure. Currently the only attribute that can be updated is the name. [Arguments] | def fusion_api_edit_enclosure(self, body, uri, api=None, headers=None):
return self.enclosure.update(body, uri, api, headers) | [
"def fusion_api_edit_enclosure_group(self, body, uri, api=None, headers=None):\n return self.enclosure_group.update(body, uri, api, headers)",
"def edit_enclosure(enc_obj):\n navigate()\n\n count = 0\n enclosure_len = len(enc_obj)\n for n, enclosure in enumerate(enc_obj):\n logger.in... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Issues a PATCH request to an enclosure. See RESTAPI docs for valid request bodies [Arguments] | def fusion_api_patch_enclosure(self, body, uri, api=None, headers=None, etag=None):
return self.enclosure.patch(body, uri, api, headers, etag) | [
"def patch(self, url, body=None, headers=None, **params):\n headers = headers or {}\n url += self.urlencode(params)\n if 'content-type' not in headers:\n # We're doing a json.dumps of body, so let's set the\n # content-type to json\n headers['content-type'] = 'a... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Removes an enclosure from the appliance based on name OR uri [Arguments] | def fusion_api_remove_enclosure(self, name=None, uri=None, param='', api=None, headers=None):
return self.enclosure.delete(name=name, uri=uri, param=param, api=api, headers=headers) | [
"def fusion_api_delete_enclosure_group(self, name=None, uri=None, api=None, headers=None):\n return self.enclosure_group.delete(name, uri, api, headers)",
"def fusion_api_delete_logical_enclosure(self, name=None, uri=None, param='', api=None, headers=None):\n return self.logical_enclosure.de... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Gets a default or paginated collection of Enclosures [Arguments] | def fusion_api_get_enclosures(self, uri=None, param='', api=None, headers=None):
return self.enclosure.get(uri=uri, param=param, api=api, headers=headers) | [
"def getEnclosures(self):\n return self.enclosures",
"def get_enclosures(self, entry):\n return [self.create_enclosure(url=enclosure.href,\n length=enclosure.length,\n type=enclosure.type)\n for enclosure in get... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Refreshes a specified Enclosure URI [Arguments] | def fusion_api_refresh_enclosure(self, body={"refreshState": "RefreshPending"}, uri=None, api=None, headers=None):
return self.enclosure.put(body, uri=uri, api=api, headers=headers) | [
"def refresh(self, url, args, cancellationSignal):\n pass",
"def GetUriCacheUpdateOp():\n pass",
"def GetUriCacheUpdateOp():\n return None",
"def refresh(self, *args):\r\n merged_args = self._build_args({}, *args)\r\n return self._call(merged_args, refresh=True)",
"def StartSRefre... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Import server hardware type for a specified Enclosure [Arguments] | def fusion_api_import_server_hardware_type_for_enclosure(self, body, uri, api=None, headers=None):
return self.enclosure.post(body, uri, api=api, headers=headers) | [
"def run_import(input_path: str, output_path: str, typ: str) -> str:\n cmd = ''\n if typ.startswith(\"FeatureTable\"):\n if not input_path.endswith('biom'):\n cur_biom = '%s.biom' % splitext(input_path)[0]\n cmd += 'biom convert \\\\\\n'\n cmd += ' -i %s \\\\\\n' % inp... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Creates the payload required to create an enclosure group [Arguments] | def fusion_api_create_enclosure_group_payload(self, body, lig_map=None, api=None):
return self.enclosure_group.make_body(api, body, lig_map) | [
"def fusion_api_create_enclosure_group(self, body, api=None, headers=None):\n return self.enclosure_group.create(body, api, headers)",
"def create_group(self, groupdata: Dict[str, Any]) -> Group:\n ...",
"def create( key , group_name, json_value_specs ):\n\n # Set name of logger with callin... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Creates an enclosure group [Arguments] | def fusion_api_create_enclosure_group(self, body, api=None, headers=None):
return self.enclosure_group.create(body, api, headers) | [
"def fusion_api_create_enclosure_group_payload(self, body, lig_map=None, api=None):\n return self.enclosure_group.make_body(api, body, lig_map)",
"def group(self, *args, **kwargs):\n def decorator(f):\n cmd = group( *args, **kwargs )( f )\n self.add_command(cmd)\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Update an enclosure group. Currently the only attribute that can be updated is the name. [Arguments] | def fusion_api_edit_enclosure_group(self, body, uri, api=None, headers=None):
return self.enclosure_group.update(body, uri, api, headers) | [
"def update_group(self, group_name):\n self._runtime_error_if_called_during_showtime('update_group')\n self._current_update_group = group_name",
"def fusion_api_update_logical_enclosure_from_group(self, uri=None, api=None, headers=None):\n param = '/updateFromGroup'\n return self.logic... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Deletes an enclosure group from the appliance based on name OR uri [Arguments] | def fusion_api_delete_enclosure_group(self, name=None, uri=None, api=None, headers=None):
return self.enclosure_group.delete(name, uri, api, headers) | [
"def delete_thing_group(thingGroupName=None, expectedVersion=None):\n pass",
"def do_del_group(dbsync, group):\n pass",
"def remove(self, group_name, change_id=None):",
"def delete_entry_group(self, name):\n self.__datacatalog.delete_entry_group(name=name)",
"def deleteGroup(groupName):\n fa... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Gets a compatiblity report. [Arguments] | def fusion_api_get_compatibility_report(self, uri, param='', api=None, headers=None):
return self.migratableVcDomain.get(uri=uri, api=api, headers=headers, param=param) | [
"def getReport(self, *args):\n return _yarp.Contactable_getReport(self, *args)",
"def getReport(self, *args):\n return _yarp.RpcClient_getReport(self, *args)",
"def getReport(self, *args):\n return _yarp.Port_getReport(self, *args)",
"def main():\n reportSample = CompatibilityReportSam... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Creates an ethernet network. [Arguments] | def fusion_api_create_ethernet_network(self, body, api=None, headers=None):
return self.ethernet_network.create(body, api, headers) | [
"def create_network(self, host, username, password, net_id):\n pass",
"def create_network(self):\n #Create the network\n self.network = Network(\"50.19.23.117\", 8080)",
"def network_create(ctx, name, blueprint):\n network = ctx.obj['CLIENT'].network.create(name, blueprint)\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Creates ethernet networks in bulk based on a VLAN ID range. [Arguments] | def fusion_api_create_ethernet_bulk_networks(self, body, api=None, headers=None):
return self.ethernet_network.bulk_create(body, api, headers) | [
"def run(self, network_create_args=None, subnet_create_args=None,\n subnet_cidr_start=None, subnets_per_network=1):\n network = self.neutron.create_network(**(network_create_args or {}))\n for _ in range(subnets_per_network):\n self.neutron.create_subnet(network[\"id\"],\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Updates an ethernet network. [Arguments] | def fusion_api_edit_ethernet_network(self, body, uri, api=None, headers=None):
return self.ethernet_network.update(body, uri, api, headers) | [
"def _send_update_network_request(self, db_session, network):\n LOG.debug(_('_send_update_network_request: %s'), network['id'])\n profile = n1kv_db_v2.get_network_profile(\n db_session, network[n1kv_profile.PROFILE_ID])\n body = {'name': network['name'],\n 'id': networ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Deletes ethernet networks in bulk based on name OR uri. [Arguments] | def fusion_api_delete_ethernet_network(self, name=None, uri=None, param='', api=None, headers=None):
return self.ethernet_network.delete(name=name, uri=uri, param=param, api=api, headers=headers) | [
"def delete_network_bulk(self, tenant_id, network_id_list, sync=False):",
"def delete_all_appliance_networks():\n FusionUIBase.navigate_to_section(SectionType.NETWORKS)\n net_list = CommonOperationNetworks.get_network_list()\n net_obj_list = []\n for net_name in net_list:\n # logger.info(\"Dele... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Gets a default or paginated collection of Ethernet networks. [Arguments] | def fusion_api_get_ethernet_networks(self, uri=None, param='', api=None, headers=None):
return self.ethernet_network.get(uri=uri, api=api, headers=headers, param=param) | [
"def get_networks(self):\n organization = self.get_organization()\n try:\n networks = self.dashboard.organizations.getOrganizationNetworks(organization['id'])\n except meraki.exceptions.APIError as exception:\n print(f\"Error: Unable to get networks: {exception}\")\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Gets the reserved vlan ID range for the fabric. [Arguments] | def fusion_api_get_fabric_reserved_vlan_range(self, uri=None, param='', api=None, headers=None):
param = "/reserved-vlan-range%s" % param
return self.fabric.get(uri=uri, api=api, headers=headers, param=param) | [
"def test_get_vlan_list_vlan_range_range_is_not_supported(self):\n self.connectivity_flow.IS_VLAN_RANGE_SUPPORTED = False\n vlan_str = \"12-10\"\n # act\n result = self.connectivity_flow._get_vlan_list(vlan_str=vlan_str)\n # verify\n self.assertEqual(set(result), {\"10\", \... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Deletes a fabric based on name OR uri provided [Arguments] | def fusion_api_delete_fabric(self, name=None, uri=None, api=None, headers=None):
return self.fabric.delete(name, uri, api, headers) | [
"def fusion_api_delete_fabric_manager(self, name, uri=None, api=None, headers=None):\n return self.fabricmanager.delete(name=name, uri=uri, api=api, headers=headers)",
"def do_host_fs_delete(cc, args):\n\n # Get the ihost object\n ihost = ihost_utils._find_ihost(cc, args.hostnameorid)\n host_f... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Patch a fabric based on uri provided [Arguments] | def fusion_api_patch_fabric(self, uri, body, api=None, headers=None):
return self.fabric.patch(uri, body, api, headers) | [
"def fusion_api_edit_fabric_manager(self, body, uri, api=None, headers=None):\n return self.fabricmanager.put(body=body, uri=uri, api=api, headers=headers)",
"def simulate_patch(app, path, **kwargs):\n return simulate_request(app, 'PATCH', path, **kwargs)",
"def fusion_api_fabric_manager_refresh(s... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Create support dump for the specified fabric uri [Arguments] | def fusion_api_create_fabric_support_dump(self, uri, body, api=None, headers=None):
params = '/support-dumps'
return self.fabric.post(uri, body, api, headers, params) | [
"def fusion_api_download_support_dump(self, uri, localfile, api=None, headers=None):\n return self.dump.get(uri=uri, localfile=localfile, api=api, headers=headers)",
"def Create(ctx,\n name,\n attributes = None):\n if ctx.element is None:\n ctx.logger.error(\"You must est... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Updates an fc network. [Arguments] | def fusion_api_edit_fc_network(self, body, uri, api=None, headers=None):
return self.fc_network.update(body, uri, api, headers) | [
"def fusion_api_edit_fcoe_network(self, body=None, uri=None, api=None, headers=None):\n return self.fcoe_network.update(body, uri, api, headers)",
"def fusion_api_edit_network_set(self, body=None, uri=None, api=None, headers=None):\n return self.network_set.update(body, uri, api, headers)",
... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Deletes an fc network from the appliance based on name OR uri [Arguments] | def fusion_api_delete_fc_network(self, name=None, uri=None, api=None, headers=None):
return self.fc_network.delete(name, uri, api, headers) | [
"def fusion_api_delete_ethernet_network(self, name=None, uri=None, param='', api=None, headers=None):\n return self.ethernet_network.delete(name=name, uri=uri, param=param, api=api, headers=headers)",
"def fusion_api_delete_network_set(self, name=None, uri=None, api=None, headers=None):\n re... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Gets a default or paginated collection of FC networks. [Arguments] | def fusion_api_get_fc_networks(self, uri=None, param='', api=None, headers=None):
return self.fc_network.get(uri=uri, api=api, headers=headers, param=param) | [
"def show_networks():\n return get_networks()",
"def getNetworksList():\n logger.debug('Start.')\n code, res = rest_requests.get(networks_url)\n if code != requests.codes.ok:\n logger.error((code, res))\n return None\n return res[\"networks\"]",
"def getNets(self):\n\t\treturn NetLo... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Updates an FCoE network. [Arguments] | def fusion_api_edit_fcoe_network(self, body=None, uri=None, api=None, headers=None):
return self.fcoe_network.update(body, uri, api, headers) | [
"def fusion_api_edit_fc_network(self, body, uri, api=None, headers=None):\n return self.fc_network.update(body, uri, api, headers)",
"def update_network(self, future, network_uuid, shared, callback):\n pass",
"def fusion_api_edit_network_set(self, body=None, uri=None, api=None, headers=None):\... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Gets a default or paginated collection of FCoE networks. [Arguments] | def fusion_api_get_fcoe_networks(self, uri=None, param='', api=None, headers=None):
return self.fcoe_network.get(uri=uri, api=api, headers=headers, param=param) | [
"def fusion_api_get_fc_networks(self, uri=None, param='', api=None, headers=None):\n return self.fc_network.get(uri=uri, api=api, headers=headers, param=param)",
"def show_networks():\n return get_networks()",
"def ex_list_networks(self):\n list_networks = []\n request = '/global/net... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Remove firmware driver from appliance. [Arguments] | def fusion_api_remove_firmware_driver(self, name=None, uri=None, api=None, headers=None):
return self.driver.delete(name, uri, api, headers) | [
"def firmware_pack_remove(handle, org_name, name, org_parent=\"org-root\"):\n org_dn = org_parent + \"/org-\" + org_name\n p_mo = handle.query_dn(org_dn)\n if not p_mo:\n log.info(\"Sub-Org <%s> not found!\" %org_name)\n else:\n fw_dn= org_dn + \"/fw-host-pack-\" + name\n mo = handl... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Get global settings [Example] ${resp} = Fusion Api Get Global Settings | | | | | def fusion_api_get_global_settings(self, uri=None, api=None, headers=None, param=''):
return self.settings.get(uri, api, headers, param) | [
"def get_global_config(baseurl, cookie_header):\n url = baseurl + 'stacking/vsf/global_config'\n headers = {'cookie': cookie_header}\n response = requests.get(url, verify=False, headers=headers)\n if response.status_code == 200:\n return response.json()\n else:\n return response.status_... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Update global settings [Arguments] | def fusion_api_update_global_settings(self, body=None, api=None, headers=None):
return self.settings.update(body, api, headers) | [
"def update_settings(settings):",
"def update_global_options(self, **kwargs):\n self._global_options.update(kwargs)",
"def update_settings(self):\n self.server_settings.update()",
"def update_global_config(self, config, **kwargs):\n pass",
"def global_setting(**kwargs):\n # Record pr... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Collects one or more IDs to be returned to a pool. The collector DTO that is returned contains the list of collected IDs [Arguments] | def fusion_api_collect_pool(self, body, uri, api=None, headers=None):
return self.idpool.collect(body, uri, api, headers) | [
"def collect(self, pds):\n\n #Send the data we have back to the master\n _ = self.comm.gather(pds.python_list, root=0)",
"def process_multiple_ids(self, data) -> list:\n\n result = []\n if data is None:\n return result\n if isinstance(data, list):\n for d i... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Gets a Pool specified by uri. [Arguments] | def fusion_api_get_pool(self, uri=None, api=None, headers=None):
return self.idpool.get(uri=uri, api=api, headers=headers) | [
"def get_pool(name):\n if name not in _CONNECTIONS:\n add_pool(name)\n return _CONNECTIONS[name]",
"def get_pool():\n app = get_app()\n return app['pool']",
"def show_pool(self, pool, **_params):\r\n return self.get(self.pool_path % (pool), params=_params)",
"def get_pool(pool_cidr):... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Creates a IPv4 Range. [Arguments] | def fusion_api_create_ipv4_range(self, body, api=None, headers=None):
return self.ipv4range.create(body, api, headers) | [
"def ip_range(self, start, end):\n return ip4_range(self.pg0.remote_ip4, start, end)",
"def ip4range(iprange):\n assert not ('/' in iprange and '-' in iprange),'cidr and dash notation is not possible'\n if '/' in iprange:\n #cidr range\n ippart,mask=iprange.split('/',1)\n mask=in... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Updates an IPv4 Range. [Arguments] | def fusion_api_edit_ipv4_range(self, body, uri, api=None, headers=None):
return self.ipv4range.update(body, uri, api, headers) | [
"def fusion_api_patch_ipv4_range(self, body, uri, param='', api=None, headers=None):\n return self.ipv4range.patch(body, uri, param, api, headers)",
"def ip_range(self, start, end):\n return ip4_range(self.pg0.remote_ip4, start, end)",
"def change_dhcp_range(self, start, end, prefix_length):\n... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Deletes a IPv4 range based on name OR uri. [Arguments] | def fusion_api_delete_ipv4_range(self, name=None, uri=None, api=None, headers=None):
return self.ipv4range.delete(name, uri, api, headers) | [
"def deleteAddressRange(self, start: ghidra.program.model.address.Address, end: ghidra.program.model.address.Address, monitor: ghidra.util.task.TaskMonitor) -> None:\n ...",
"def fusion_api_delete_vsn_range(self, name=None, uri=None, api=None, headers=None):\n return self.vsnrange.delete(name, u... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Gets a default or paginated collection of IPv4 Ranges. [Arguments] | def fusion_api_get_ipv4_range(self, uri=None, param='', api=None, headers=None):
return self.ipv4range.get(uri=uri, api=api, headers=headers, param=param) | [
"def ip_range(self, start, end):\n return ip4_range(self.pg0.remote_ip4, start, end)",
"def ipv4_address_list(ipv4_range):\n\n if is_ipv4_address(ipv4_range):\n return [ipv4_range]\n\n elif is_ipv4_range(ipv4_range):\n start_address, end_address = ipv4_range.split('-')\n\n ipv4_l... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Allocate an IPv4 Range. [Arguments] | def fusion_api_allocate_ipv4_range(self, body, uri, api=None, headers=None):
return self.ipv4range.allocate(body, uri, api, headers) | [
"def fusion_api_create_ipv4_range(self, body, api=None, headers=None):\n return self.ipv4range.create(body, api, headers)",
"def ip_range(self, start, end):\n return ip4_range(self.pg0.remote_ip4, start, end)",
"def create_range(self, session, allocation_pool_id,\n range_st... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Collect an IPv4 Range. [Arguments] | def fusion_api_collect_ipv4_range(self, body, uri, api=None, headers=None):
return self.ipv4range.collect(body, uri, api, headers) | [
"def ip_range(self, start, end):\n return ip4_range(self.pg0.remote_ip4, start, end)",
"def ip4range(iprange):\n assert not ('/' in iprange and '-' in iprange),'cidr and dash notation is not possible'\n if '/' in iprange:\n #cidr range\n ippart,mask=iprange.split('/',1)\n mask=in... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Returns all fragments that have been allocated from a IPv4 Range [Arguments] | def fusion_api_get_ipv4_range_allocated_fragments(self, uri, api=None, headers=None):
return self.ipv4range.get(uri=uri, api=api, headers=headers, param='/allocated-fragments') | [
"def ip_range(self, start, end):\n return ip4_range(self.pg0.remote_ip4, start, end)",
"def fusion_api_get_vsn_range_allocated_fragments(self, uri, api=None, headers=None):\n return self.vsnrange.get(uri=uri, api=api, headers=headers, param='/allocated-fragments')",
"def fusion_api_get_ipv4_ra... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Returns all the free fragments in a IPv4 Range. [Arguments] | def fusion_api_get_ipv4_range_free_fragments(self, uri, api=None, headers=None):
return self.ipv4range.get(uri=uri, api=api, headers=headers, param='/free-fragments') | [
"def fusion_api_get_ipv4_range_allocated_fragments(self, uri, api=None, headers=None):\n return self.ipv4range.get(uri=uri, api=api, headers=headers, param='/allocated-fragments')",
"def fusion_api_get_vmac_range_free_fragments(self, uri, api=None, headers=None):\n return self.vmacrange.get(... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Patch an IPv4 Range. [Arguments] | def fusion_api_patch_ipv4_range(self, body, uri, param='', api=None, headers=None):
return self.ipv4range.patch(body, uri, param, api, headers) | [
"def fusion_api_edit_ipv4_range(self, body, uri, api=None, headers=None):\n return self.ipv4range.update(body, uri, api, headers)",
"def change_dhcp_range(self, start, end, prefix_length):\n self.execute_script('change_dhcp_range', start, end, prefix_length)",
"def ip_range(self, start, end):\... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Creates a IPv4 Subnet. [Arguments] | def fusion_api_create_ipv4_subnet(self, body, sessionID=None, api=None, headers=None):
return self.ipv4subnet.create(body, sessionID, api, headers) | [
"def make_subnetwork(self, name, *args, **kwargs):\n return self.network.make_subnetwork('%s.%s'%(self.name, name), *args, **kwargs)",
"def subnet_create(request, network_id, **kwargs):\n LOG.debug(\"subnet_create(): netid=%(network_id)s, kwargs=%(kwargs)s\",\n {'network_id': network_id, 'k... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Deletes a IPv4 Subnet based on name OR uri. [Arguments] | def fusion_api_delete_ipv4_subnet(self, name=None, uri=None, api=None, headers=None):
return self.ipv4subnet.delete(name, uri, api, headers) | [
"def delete_subnet(compute, project, region, name):\n return compute.subnetworks().delete(project=project, region=region,\n subnetwork=name).execute()",
"def delete_db_subnet_group(DBSubnetGroupName=None):\n pass",
"def delete_subnet(self, name_or_id):\n subne... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Updates an IPv4 Subnet. [Arguments] | def fusion_api_edit_ipv4_subnet(self, body, uri, api=None, headers=None):
return self.ipv4subnet.update(body, uri, api, headers) | [
"def fusion_api_patch_ipv4_subnet(self, body, uri, param='', api=None, headers=None):\n return self.ipv4subnet.patch(body, uri, param, api, headers)",
"def _send_update_subnet_request(self, subnet):\n LOG.debug('_send_update_subnet_request: %s', subnet['name'])\n n1kvclient = n1kv_client.... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Allocate an IPv4 Subnet. [Arguments] | def fusion_api_allocate_ipv4_subnet(self, body, uri, api=None, headers=None):
return self.ipv4subnet.allocate(body, uri, api, headers) | [
"def allocate_subnet(self):\n if len(self.subnet_list) == 0:\n subnet = '192.168.1.0/24'\n self.subnet_list.append(subnet)\n return subnet\n else:\n subnet = self.subnet_list[::-1][0]\n ip = ipaddress.IPv4Network(subnet)[0]\n s = ipaddr... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Collect an IPv4 Subnet. [Arguments] | def fusion_api_collect_ipv4_subnet(self, body, uri, api=None, headers=None):
return self.ipv4subnet.collect(body, uri, api, headers) | [
"def subnetwork_to_ip_range(subnetwork):\n \n try:\n fragments = subnetwork.split('/')\n network_prefix = fragments[0]\n netmask_len = int(fragments[1])\n \n # try parsing the subnetwork first as IPv4, then as IPv6\n for version in (socket.AF_INET, socket.AF_INET6):\n \n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Patch an IPv4 Subnet. [Arguments] | def fusion_api_patch_ipv4_subnet(self, body, uri, param='', api=None, headers=None):
return self.ipv4subnet.patch(body, uri, param, api, headers) | [
"def test_patch_host_subnet(self):\n pass",
"def fusion_api_edit_ipv4_subnet(self, body, uri, api=None, headers=None):\n return self.ipv4subnet.update(body, uri, api, headers)",
"def test_replace_host_subnet(self):\n pass",
"def _send_update_subnet_request(self, subnet):\n LOG.... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Creates a VMAC Range. [Arguments] | def fusion_api_create_vmac_range(self, body, api=None, headers=None):
return self.vmacrange.create(body, api, headers) | [
"def vrange(start, stop, step=1, dtype='f8'):\n from .column import ColumnVirtualRange\n return ColumnVirtualRange(start, stop, step, dtype)",
"def create_range(self, session, allocation_pool_id,\n range_start, range_end):\n new_ip_range = db_models.IpamAvailabilityRange(\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Updates an VMAC Range. [Arguments] | def fusion_api_edit_vmac_range(self, body, uri, api=None, headers=None):
return self.vmacrange.update(body, uri, api, headers) | [
"def fusion_api_create_vmac_range(self, body, api=None, headers=None):\n return self.vmacrange.create(body, api, headers)",
"def update(\n self,\n AccessAggregationCbTlv=None,\n AtmVci=None,\n AtmVpi=None,\n CircuitId=None,\n DistributionAlgorithmPercent=None,\... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Deletes a VMAC range based on name OR uri. [Arguments] | def fusion_api_delete_vmac_range(self, name=None, uri=None, api=None, headers=None):
return self.vmacrange.delete(name, uri, api, headers) | [
"def fusion_api_delete_vsn_range(self, name=None, uri=None, api=None, headers=None):\n return self.vsnrange.delete(name, uri, api, headers)",
"def fusion_api_delete_vwwn_range(self, name=None, uri=None, api=None, headers=None):\n return self.vwwnrange.delete(name, uri, api, headers)",
"def... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Gets a default or paginated collection of VMAC Ranges. [Arguments] | def fusion_api_get_vmac_range(self, uri=None, param='', api=None, headers=None):
return self.vmacrange.get(uri=uri, api=api, headers=headers, param=param) | [
"def get_range(self, start, end):",
"def getRange(self):\n \n pass",
"def fusion_api_get_vmac_range_allocated_fragments(self, uri, api=None, headers=None):\n return self.vmacrange.get(uri=uri, api=api, headers=headers, param='/allocated-fragments')",
"def _macs_to_ranges(macs):\n r... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Returns all fragments that have been allocated from a VMAC Range [Arguments] | def fusion_api_get_vmac_range_allocated_fragments(self, uri, api=None, headers=None):
return self.vmacrange.get(uri=uri, api=api, headers=headers, param='/allocated-fragments') | [
"def fusion_api_get_vsn_range_allocated_fragments(self, uri, api=None, headers=None):\n return self.vsnrange.get(uri=uri, api=api, headers=headers, param='/allocated-fragments')",
"def fusion_api_get_vmac_range_free_fragments(self, uri, api=None, headers=None):\n return self.vmacrange.get(ur... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Returns all the free fragments in a VMAC Range. [Arguments] | def fusion_api_get_vmac_range_free_fragments(self, uri, api=None, headers=None):
return self.vmacrange.get(uri=uri, api=api, headers=headers, param='/free-fragments') | [
"def fusion_api_get_vmac_range_allocated_fragments(self, uri, api=None, headers=None):\n return self.vmacrange.get(uri=uri, api=api, headers=headers, param='/allocated-fragments')",
"def fusion_api_get_vsn_range_free_fragments(self, uri, api=None, headers=None):\n return self.vsnrange.get(ur... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Creates a VSN Range. [Arguments] | def fusion_api_create_vsn_range(self, body, api=None, headers=None):
return self.vsnrange.create(body, api, headers) | [
"def createRange(self, lowerBound, upperBound):\n lowerBound = self.object_position_term_to_openrdf_term(lowerBound)\n upperBound = self.object_position_term_to_openrdf_term(upperBound)\n return RangeLiteral(lowerBound=lowerBound, upperBound=upperBound)",
"def build_range(identity: str, type_... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Updates an VSN Range. [Arguments] | def fusion_api_edit_vsn_range(self, body, uri, api=None, headers=None):
return self.vsnrange.update(body, uri, api, headers) | [
"def set_subs_range (self, start=None, end=None):\n self.check_range_to_edit = self.edit_range(start, end)",
"def change_dhcp_range(self, start, end, prefix_length):\n self.execute_script('change_dhcp_range', start, end, prefix_length)",
"def fusion_api_edit_vwwn_range(self, body, uri, api=None, h... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Deletes a VSN range based on name OR uri. [Arguments] | def fusion_api_delete_vsn_range(self, name=None, uri=None, api=None, headers=None):
return self.vsnrange.delete(name, uri, api, headers) | [
"def fusion_api_delete_vwwn_range(self, name=None, uri=None, api=None, headers=None):\n return self.vwwnrange.delete(name, uri, api, headers)",
"def fusion_api_delete_vmac_range(self, name=None, uri=None, api=None, headers=None):\n return self.vmacrange.delete(name, uri, api, headers)",
"d... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Gets a default or paginated collection of VSN Ranges. [Arguments] | def fusion_api_get_vsn_range(self, uri=None, param='', api=None, headers=None):
return self.vsnrange.get(uri=uri, api=api, headers=headers, param=param) | [
"def get_range(self, start, end):",
"def getRange(self):\n \n pass",
"def ranges(self):\r\n _name,rangeStrs = self._nameAndRangeStrs()\r\n return list(map(lambda x: Range(x), rangeStrs))",
"def get_range(min_val, max_val):\n return range(min_val, max_val)",
"def ranges(self) -> Op... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Returns all fragments that have been allocated from a VSN Range [Arguments] | def fusion_api_get_vsn_range_allocated_fragments(self, uri, api=None, headers=None):
return self.vsnrange.get(uri=uri, api=api, headers=headers, param='/allocated-fragments') | [
"def fusion_api_get_vmac_range_allocated_fragments(self, uri, api=None, headers=None):\n return self.vmacrange.get(uri=uri, api=api, headers=headers, param='/allocated-fragments')",
"def fusion_api_get_vwwn_range_allocated_fragments(self, uri, api=None, headers=None):\n return self.vwwnrange... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Returns all the free fragments in a VSN Range. [Arguments] | def fusion_api_get_vsn_range_free_fragments(self, uri, api=None, headers=None):
return self.vsnrange.get(uri=uri, api=api, headers=headers, param='/free-fragments') | [
"def fusion_api_get_vmac_range_free_fragments(self, uri, api=None, headers=None):\n return self.vmacrange.get(uri=uri, api=api, headers=headers, param='/free-fragments')",
"def fusion_api_get_vwwn_range_free_fragments(self, uri, api=None, headers=None):\n return self.vwwnrange.get(uri=uri, a... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Creates a VWWN Range. [Arguments] | def fusion_api_create_vwwn_range(self, body, api=None, headers=None):
return self.vwwnrange.create(body, api, headers) | [
"def createRange(self, lowerBound, upperBound):\n lowerBound = self.object_position_term_to_openrdf_term(lowerBound)\n upperBound = self.object_position_term_to_openrdf_term(upperBound)\n return RangeLiteral(lowerBound=lowerBound, upperBound=upperBound)",
"def vrange(start, stop, step=1, dtyp... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Updates an VWWN Range. [Arguments] | def fusion_api_edit_vwwn_range(self, body, uri, api=None, headers=None):
return self.vwwnrange.update(body, uri, api, headers) | [
"def do_upw(self, arg):\n self.do_timesheet('update week')",
"def update_vow(_params, _substep, _state_hist, state, policy_signals):\n\n new_vow = policy_signals.get(\"vow\", state[\"vow\"])\n return (\"vow\", new_vow)",
"def update_w(w_vector, gradient_vector):\n for index in range(len(w_vector... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Deletes a VWWN range based on name OR uri. [Arguments] | def fusion_api_delete_vwwn_range(self, name=None, uri=None, api=None, headers=None):
return self.vwwnrange.delete(name, uri, api, headers) | [
"def fusion_api_delete_vsn_range(self, name=None, uri=None, api=None, headers=None):\n return self.vsnrange.delete(name, uri, api, headers)",
"def fusion_api_delete_ipv4_range(self, name=None, uri=None, api=None, headers=None):\n return self.ipv4range.delete(name, uri, api, headers)",
"def... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Gets a default or paginated collection of VWWN Ranges. [Arguments] | def fusion_api_get_vwwn_range(self, uri=None, param='', api=None, headers=None):
return self.vwwnrange.get(uri=uri, api=api, headers=headers, param=param) | [
"def get_range(self, start, end):",
"def getRange(self):\n \n pass",
"def myrange(start, end, step):\n\t \n\t\t if end==start:\n\t\t return list\n\t\t\t else:\n\t\t\t\t list.append(start)\n\t\t\t\t\t if start+step>= end:\n\t\t\t\t\t\t return list\n\... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Returns all fragments that have been allocated from a VWWN Range [Arguments] | def fusion_api_get_vwwn_range_allocated_fragments(self, uri, api=None, headers=None):
return self.vwwnrange.get(uri=uri, api=api, headers=headers, param='/allocated-fragments') | [
"def fusion_api_get_vsn_range_allocated_fragments(self, uri, api=None, headers=None):\n return self.vsnrange.get(uri=uri, api=api, headers=headers, param='/allocated-fragments')",
"def fusion_api_get_vmac_range_allocated_fragments(self, uri, api=None, headers=None):\n return self.vmacrange.g... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Returns all the free fragments in a VWWN Range. [Arguments] | def fusion_api_get_vwwn_range_free_fragments(self, uri, api=None, headers=None):
return self.vwwnrange.get(uri=uri, api=api, headers=headers, param='/free-fragments') | [
"def fusion_api_get_vsn_range_free_fragments(self, uri, api=None, headers=None):\n return self.vsnrange.get(uri=uri, api=api, headers=headers, param='/free-fragments')",
"def fusion_api_get_vmac_range_free_fragments(self, uri, api=None, headers=None):\n return self.vmacrange.get(uri=uri, api... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Gets a default or paginated collection of Interconnect Types. [Arguments] | def fusion_api_get_interconnect_types(self, param='', api=None, headers=None):
return self.ictypes.get(api=api, headers=headers, param=param) | [
"def connectionTypes(request: HttpRequest) -> Response:\n if request.method == \"GET\":\n res = Connections.getConnectionTypes()\n return Response(res.json())",
"def get_integrations_types(self, **kwargs):\n\n all_params = ['page_size', 'page_number', 'sort_by', 'expand', 'next_page', 'pre... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Gets the port statistics details for givenInterconnect [Arguments] | def fusion_api_get_interconnect_port_statistics(self, uri, param='', api=None, headers=None):
param = '/statistics/%s' % param
return self.ic.get(uri=uri, api=api, headers=headers, param=param) | [
"def get_port_stats(self, **kwargs):\n print(\"### get port stats ###\")\n port_stat = dict()\n if 'port' in kwargs:\n port = kwargs.get('port')\n output = getattr(self.warp17_obj, 'shell')(command=\"show port statistics\", pattern=\"warp17>\").response()\n out = outpu... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Issues an Patch Interconnect request for Potash\Potassium modules [Arguments] | def fusion_api_patch_interconnect(self, body, uri, param='', api=None, headers=None):
return self.ic.patch(body=body, uri=uri, api=api, headers=headers, param=param) | [
"def http_patch(self, url, **kwargs):\n logger.debug('Entered QiitaClient.http_patch()')\n return self._request_retry(self._session.patch, url, **kwargs)",
"def simulate_patch(app, path, **kwargs) -> _ResultBase:\n return simulate_request(app, 'PATCH', path, **kwargs)",
"def simulate_patch(app,... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Updates the port details for given Interconnect [Arguments] | def fusion_api_edit_interconnect_ports(self, body, uri, api=None, param='', headers=None):
param = '/update-ports%s' % param
return self.ic.put(body=body, uri=uri, api=api, headers=headers, param=param) | [
"def port_update(self, context, **kwargs):\n self._refresh_bridge_mappings_to_neutron()",
"def update(clients, context, name=None):\n port_id = context['port_id']\n logger.info(\"Taking action port.update {}.\".format(port_id))\n neutron = clients.get_neutron()\n body = {'port': {}}\n if nam... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Clear the port counter details for given Interconnect [Arguments] | def fusion_api_clear_interconnect_ports(self, body, uri, api=None, param='', headers=None):
param = '/statistics/reset%s' % param
return self.ic.put(body=body, uri=uri, api=api, headers=headers, param=param) | [
"def clear_port_stats(self) -> None:\n stat = IxeStat(self)\n stat.ix_set_default()\n stat.enableValidStats = True\n stat.ix_set()\n stat.write()",
"def reset_counters():\n db = CounterDB()\n db.update_in(0)\n db.update_out(0)",
"def ClearPortsAndTrafficStats(self, *a... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Gets the nameServers details for given Interconnect. This info is for DirectAttach connection info [Arguments] | def fusion_api_get_interconnect_nameservers(self, uri=None, api=None, param='', headers=None):
param = '/nameServers%s' % param
return self.ic.get(uri=uri, api=api, headers=headers, param=param) | [
"def netapi32_NetServerGetInfo(jitter):\n ret_ad, args = jitter.func_args_stdcall([\"servername\", \"level\", \"bufptr\"])\n raise RuntimeError('API not implemented')\n jitter.func_ret_stdcall(ret_ad, ret_value)",
"def netapi32_NetMessageNameGetInfo(jitter):\n ret_ad, args = jitter.func_args_stdcall([... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Gets the certificate details for givenInterconnect [Arguments] | def fusion_api_get_certificate_info(self, uri=None, api=None, param='', headers=None):
param = '/certificates/https/'
return self.ic.get(uri=uri, api=api, headers=headers, param=param) | [
"def get_ssl_certificate() :",
"def describe_certificate(certificateId=None):\n pass",
"def get_ssl_ca_cert_detail(device=None, lsys=None, tenant=None, node=\"local\", cert_id=None, pic_info=None):\n if device is None:\n raise ValueError(\"'device' is a mandatory argument\")\n\n if cert_id is No... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Uploads the certificate details for givenInterconnect [Arguments] | def fusion_api_upload_certificate_info(self, body, uri=None, api=None, param='', headers=None):
param = '/certificates/https/'
return self.ic.put(body=body, uri=uri, api=api, headers=headers, param=param) | [
"def upload(name, certfile, keyfile, chainfile):\n try:\n cmd = client().certificates.upload\n job, data = cmd(name, certfile, keyfile, chainfile)\n handle_job(job)\n except Exception as e:\n raise CLIException(str(e))",
"def Certificate(self) -> _n_8_t_0:",
"def test_issue_cer... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
GET on /rest/interconnectlinktopologies [Example] ${resp} = Fusion Api Get Interconnect Link Topology | | | def fusion_api_get_interconnect_link_topology(self, api=None, headers=None):
return self.ilt.get(api=api, headers=headers) | [
"def ontology():\n return OKJSONResponse(ONTOLOGY)",
"def get_topology(odl_url, odl_usr, odl_pass):\n if odl_url.endswith('/'):\n odl_url = odl_url[:-1]\n topology_url = odl_url + '/network-topology:network-topology/'\n topology_json = call_odl_api(odl_usr, odl_pass, topology_url)\n return t... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Gets a default or paginated collection of Interconnect Link Sets [Arguments] | def fusion_api_get_internal_link_sets(self, uri=None, param='', api=None, headers=None):
return self.ils.get(uri=uri, api=api, headers=headers, param=param) | [
"def getInterWikiLinks(self):\n pass",
"def listSets(self, *args, **kwargs):\n \n pass",
"def get_queryset(self):\n\n return Link.objects.all()",
"def _get_links(args):\n\n return _get_links_header(args), wikidata.get_links(**args.__dict__)",
"def listSets(*args, **kwargs):\n\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Adds a license to the appliance [Arguments] | def fusion_api_add_license(self, key=None, license_type='LicenseV500', api=None, headers=None):
return self.license.add(key, license_type, api, headers) | [
"def add_license_record(self):\n license = self.tale.get('licenseSPDX', WholeTaleLicense.default_spdx())\n self.manifest['aggregates'].append(\n {'uri': './LICENSE', 'schema:license': license}\n )",
"def install_license():\n query = {\n \"type\": \"op\",\n \"cmd\":... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Deletes a License from the appliance based on uri [Arguments] | def fusion_api_remove_license(self, uri=None, api=None, headers=None):
return self.license.delete(uri=uri, api=api, headers=headers) | [
"def catalog_delete(self, args):\n headers = DEFAULT_HEADERS.copy()\n headers.update(args.headers)\n try:\n catalog = self.server.connect_ermrest(args.id)\n catalog.delete(args.path, headers)\n except HTTPError as e:\n if e.response.status_code == request... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Deletes All Licenses from the appliance [Arguments] None [Example] Fusion API Remove All Licenses | def fusion_api_remove_all_licenses(self):
all_licenses = self.fusion_api_get_licenses()
for lic in all_licenses['members']:
response = self.fusion_api_remove_license(uri=lic['uri'])
if response.status_code != 204:
logger._log_to_console_and_... | [
"def rmAllDistributions(self):\n\n self.candDistsTable.clearContents()\n self.candDistsTable.setRowCount(0)\n self.cDists.remove_all()\n self.rmButton.setEnabled(False)\n self.rmAllButton.setEnabled(False)\n self.scipyCallButton.setEnabled(False)\n self.pdfcdfButton.... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Gets a default or paginated collection of Logical Downlinks. [Arguments] | def fusion_api_get_logical_downlink(self, uri=None, api=None, headers=None, param=''):
return self.ld.get(uri=uri, api=api, headers=headers, param=param) | [
"def _get_links(args):\n\n return _get_links_header(args), wikidata.get_links(**args.__dict__)",
"def get_links(self, numlinks=None):\n return self.links[:numlinks]",
"def dl_list(self):\n return self._get_json('user/download-list')",
"def get_backlinks(self,req=None,formatted=False):\n ba... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Create the LIG payload | def fusion_api_create_lig_payload(self, **kwargs):
return self.lig.make_body(**kwargs) | [
"def _make_payload(self, **kwargs):\n pass",
"def make_payload(self):\n return Payload(\n language=self.language,\n audio_source = self.audio_source,\n words=self.words,\n sentences=self.sentences,\n grammar=self.grammar)... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Deletes an LIG from the appliance based on name OR uri [Arguments] | def fusion_api_delete_lig(self, name=None, uri=None, api=None, headers=None, etag=None):
return self.lig.delete(name=name, uri=uri, api=api, headers=headers, etag=etag) | [
"def fusion_api_delete_lsg(self, name=None, uri=None, api=None, headers=None):\n return self.lsg.delete(name=name, uri=uri, api=api, headers=headers)",
"def delete(self, name):\n if name:\n try:\n del self._uris[name]\n except KeyError:\n pass"... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Deletes an interconnect from a LI location [Arguments] | def fusion_api_delete_li_interconnect(self, location, api=None, headers=None):
return self.li.delete(location=location, api=api, headers=headers) | [
"def delete_interconnect(interconnectId=None):\n pass",
"def delete_location(self, location_id):",
"def removeNeighbor(self, neighborID):",
"def delete(cls, ip_list_id: int) -> None:\n\t\tpass",
"def delete_loc(lid):\r\n\r\n db = get_db()\r\n b_id = session.get(\"user_id\")\r\n db.execute(\r\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Gets the ethernetSettings for the given LI [Arguments] | def fusion_api_get_li_ethernet_settings(self, uri, api=None, headers=None):
param = '/ethernetSettings'
return self.li.get(uri=uri, api=api, headers=headers, param=param) | [
"def eth_settings(self):\n return self._eth_settings",
"def network_settings(self): # type: () -> t.Dict[str, t.Any]\n return self.inspection['NetworkSettings']",
"def GetTapSettings(self, *args, **kwargs):\n # type: (*Any, **Any) -> None\n payload = { \"Arg1\": self }\n for ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Gets the fcoeSettings for the given LI [Arguments] | def fusion_api_get_li_fcoe_settings(self, uri, api=None, headers=None):
param = '/fcoeSettings'
return self.li.get(uri=uri, api=api, headers=headers, param=param) | [
"def _get_config_data(arguments):\n if arguments.get(\"felix\"):\n config_data = FELIX_CONFIG_DATA\n else:\n config_data = BGP_CONFIG_DATA\n return config_data",
"def ffn_runs(env):\n\n # different parameters to vary, first entry is name of parameter, second is possible values\n\n par... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Generates the fowarding information base dump file for the given LI [Arguments] | def fusion_api_generate_li_forwarding_information_base_dump_file(self, uri, api=None, headers=None):
param = '/forwarding-information-base'
return self.li.post(uri=uri, api=api, headers=headers, param=param) | [
"def genDump(exePath,inputDict,outputDict):\n paramFile = path.join(path.dirname(inputDict),'damo.par')\n with open(paramFile,'w') as f:\n f.write('DUMP'+'\\n')\n f.write(inputDict+'\\n')\n f.write(outputDict)\n runDamocles(exePath, paramFile)\n remove(paramFile)",
"def genPDBstructd():\n\n... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Gets the fowarding information base dump file for the given LI [Arguments] | def fusion_api_get_li_forwarding_information_base_dump_file(self, uri, localfile, api=None, headers=None):
return self.li.get_file(uri=uri, localfile=localfile, api=api, headers=headers) | [
"def top_PDBfile(self):\n return \"%s.1.pdb\" % os.path.basename(self.root)",
"def fusion_api_generate_li_forwarding_information_base_dump_file(self, uri, api=None, headers=None):\n param = '/forwarding-information-base'\n return self.li.post(uri=uri, api=api, headers=headers, param=p... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Updates an LI using the PATCH http verb. [Arguments] | def fusion_api_patch_li(self, body=None, uri=None, api=None, headers=None):
return self.li.patch(body, uri, api, headers) | [
"def patch(*args, **kwargs):\n return update(*args, patch=True, **kwargs)",
"def patch(self, *args, **kwargs):\n return self.handle_patch_request()",
"def partial_update(self, request, pk=None): #partial update a specific object\n return Response({'http_method': 'PATCH'})",
"def update():\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Gets the Port Monitor for the given LI [Arguments] | def fusion_api_get_li_port_monitor_configuration(self, uri, api=None, headers=None):
param = '/port-monitor'
return self.li.get(uri=uri, api=api, headers=headers, param=param) | [
"def monitor(address, mon):\n return address(Monitor, monitor=mon)",
"def query(self):\n uri = common.genuri('lswitch', self.lswitch_uuid, 'lport')\n queryobject = nvpquery.LSwitchPortQuery(self.connection, uri)\n return queryobject",
"def port_monitor(self, name, hostname, port, interva... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Updates the ethernetSettings for the given LI [Arguments] | def fusion_api_update_li_ethernet_settings(self, body=None, uri=None, api=None, headers=None):
param = '/ethernetSettings'
return self.li.update(body=body, uri=uri, api=api, headers=headers, param=param) | [
"def eth_settings(self, eth_settings):\n\n self._eth_settings = eth_settings",
"def platform_config_update(config):\n\n remote_port_map = {(0, int(i.replace('eth', ''))) : i for i in get_ifaces()}\n config[\"port_map\"] = remote_port_map.copy()\n config[\"caps_table_idx\"] = 0",
"def update_conf... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Updates the fcoeSettings for the given LI [Arguments] | def fusion_api_update_li_fcoe_settings(self, body=None, uri=None, api=None, headers=None):
param = '/fcoeSettings'
return self.li.update(body=body, uri=uri, api=api, headers=headers, param=param) | [
"def update_coeff(self, **kwargs: float) -> None:\n for rule_name, coeff in kwargs.items():\n if rule_name not in self.rules:\n raise ValueError(f\"Behavioral rule {rule_name} does not exist\")\n else:\n self.rules[getattr(self, rule_name)] = coeff",
"def... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Updates the internalNetworks for the given LI [Arguments] | def fusion_api_update_li_internal_networks(self, body=None, uri=None, api=None, headers=None):
param = '/internalNetworks'
return self.li.update(body=body, uri=uri, api=api, headers=headers, param=param) | [
"def _update_networks(self):\n\n if self.update_type == \"soft\":\n self._soft_update(self.q, self.q_target)\n elif self.t_step % self.C == 0:\n self._hard_update(self.q, self.q_target)",
"async def updatelogicalnetworks(self,networks: [{\"id\": str,\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Updates the Port Monitor for the given LI [Arguments] | def fusion_api_update_li_port_monitor_configuration(self, body=None, uri=None, api=None, headers=None):
param = '/port-monitor'
return self.li.update(body=body, uri=uri, api=api, headers=headers, param=param) | [
"def update(self):\n uri = common.genuri('lswitch', self.lswitch_uuid, 'lport', self.uuid)\n return super(LSwitchPort, self)._action('PUT', uri)",
"def port_update(self, context, **kwargs):\n self._refresh_bridge_mappings_to_neutron()",
"def monitor_midi(port):\n\n port = mido.open_input... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Updates the telemetry configuration for the given LI [Arguments] | def fusion_api_update_li_telemetry_configuration(self, body=None, uri=None, api=None, headers=None):
return self.li.update(body=body, uri=uri, api=api, headers=headers, param="") | [
"def update(self, *args, **kwargs):\n self.logger.update(*args, **kwargs)",
"def update_from_args(self, args):\n\n self.plugin_dirs.update(args.plugin_dirs)\n self.hooks.update(getattr(args, \"hooks\", []))\n\n if getattr(args, \"forklimit\", None) is not None:\n self.forkli... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Updates the qosaggregatedconfiguration for the given LI [Arguments] | def fusion_api_update_qos_aggregated_configuration(self, body=None, uri=None, api=None, headers=None):
param = '/qos-aggregated-configuration'
return self.li.update(body=body, uri=uri, api=api, headers=headers, param=param) | [
"def test_update_qos_config(self):\n qos_config = self._create_qos_configs()\n display_name = data_utils.rand_name('qos_config')\n with self.rbac_utils.override_role(self):\n self.qos_client.update_qos_config(\n qos_config_id=qos_config['uuid'],\n displa... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Updates the redistribute logins for the given LI [Arguments] | def fusion_api_update_redistribute_logins(self, body=None, uri=None, api=None, headers=None):
param = '/redistributeLogins'
return self.li.update(body=body, uri=uri, api=api, headers=headers, param=param) | [
"def update_from_logins(self, logins):\n # Now add contributors using cache (new GitHub contributors) with known email or orcid that isn't present\n for login in logins:\n # Check against contribution threshold, and not bot\n if not self.include_contributor(login):\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Updates the snmp_configuration for the given LI [Arguments] | def fusion_api_update_snmp_configuration(self, body=None, uri=None, api=None, headers=None):
param = '/snmp-configuration'
return self.li.update(body=body, uri=uri, api=api, headers=headers, param=param) | [
"def update_config_item(self, elements: Dict[str, Any]) -> None:\n ...",
"def update_from_args(self, args):\n\n self.plugin_dirs.update(args.plugin_dirs)\n self.hooks.update(getattr(args, \"hooks\", []))\n\n if getattr(args, \"forklimit\", None) is not None:\n self.forklimit... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Updates the sflow_configuration for the given LI [Arguments] | def fusion_api_update_sflow_configuration(self, body=None, uri=None, api=None, headers=None):
param = '/sflow-configuration'
return self.li.update(body=body, uri=uri, api=api, headers=headers, param=param) | [
"def update_flow(self, flow):\r\n self.flow = flow",
"def configSFlow(self, ifname, collector, sampling, polling):\n\n net = self.net\n info(\"**** [G2]: enabling sFlow:\\n\")\n sflow = 'ovs-vsctl -- --id=@sflow create sflow agent=%s target=%s sampling=%s polling=%s --' % (ifname, coll... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Deletes an LSG from the appliance based on name OR uri [Arguments] | def fusion_api_delete_lsg(self, name=None, uri=None, api=None, headers=None):
return self.lsg.delete(name=name, uri=uri, api=api, headers=headers) | [
"def fusion_api_delete_lig(self, name=None, uri=None, api=None, headers=None, etag=None):\n return self.lig.delete(name=name, uri=uri, api=api, headers=headers, etag=etag)",
"def fusion_api_delete_sas_lig(self, name=None, uri=None, api=None, headers=None):\n return self.saslig.delete(name=na... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Gets a default or paginated collection of LSGs. [Arguments] | def fusion_api_get_lsg(self, uri=None, param='', api=None, headers=None):
return self.lsg.get(uri=uri, param=param, api=api, headers=headers) | [
"def _get_glossaries(self, limit=-1, offset=0, sort_order=\"ASC\"):\n results = None\n atlas_endpoint = self.endpoint_url + \"/glossary\"\n logging.debug(\"Retreiving all glossaries from catalog\")\n\n # TODO: Implement paging with offset and limit\n getResult = requests.get(\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |