query stringlengths 9 9.05k | document stringlengths 10 222k | negatives listlengths 19 20 | metadata dict |
|---|---|---|---|
Describes available AWS services in a prefix list format, which includes the prefix list name and prefix list ID of the service and the IP address range for the service. A prefix list ID is required for creating an outbound security group rule that allows traffic from a VPC to access an AWS service through a VPC endpoi... | def describe_prefix_lists(DryRun=None, PrefixListIds=None, Filters=None, MaxResults=None, NextToken=None):
pass | [
"def services(self):\n _log.debug('get service list')\n result = self._requestJSON('services', '')\n return self._getKey(result, 'name')",
"def list_services(ctx):\n\n ctx.respond(ctx._(\"I am running: {services}\").format(\n services=\", \".join(ctx.bot.services))\n )",
"def g... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Describes one or more regions that are currently available to you. For a list of the regions supported by Amazon EC2, see Regions and Endpoints . | def describe_regions(DryRun=None, RegionNames=None, Filters=None):
pass | [
"def get_us_aws_regions():\n try:\n resp = boto3.client('ec2').describe_regions()\n return [reg['RegionName'] for reg in resp['Regions'] if 'us-' in reg['RegionName']]\n except BaseException as err:\n print_err(err)",
"def regions():\n from boto.directconnect.layer1 import DirectConn... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Describes one or more of the Reserved Instances that you purchased. For more information about Reserved Instances, see Reserved Instances in the Amazon Elastic Compute Cloud User Guide . | def describe_reserved_instances(DryRun=None, ReservedInstancesIds=None, Filters=None, OfferingType=None, OfferingClass=None):
pass | [
"def getReservedInstances(verbose):\n lres = {}\n jResp = EC2C.describe_reserved_instances()\n for reserved in jResp['ReservedInstances']:\n if reserved['State'] == 'active':\n if verbose:\n lres[reserved['InstanceType']] = str(reserved['Start'])+\";\"+\\\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Describes the modifications made to your Reserved Instances. If no parameter is specified, information about all your Reserved Instances modification requests is returned. If a modification ID is specified, only information about the specific modification is returned. For more information, see Modifying Reserved Instan... | def describe_reserved_instances_modifications(ReservedInstancesModificationIds=None, NextToken=None, Filters=None):
pass | [
"def get_modification(self) -> str:\n return self._root[\"Modification\"]",
"def modification_id(self, modification_id):\n\n self._modification_id = modification_id",
"def modified(object, *descriptions):",
"def changes(self) -> List[str]:\n output: List[str] = []\n if self.status(... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Describes Reserved Instance offerings that are available for purchase. With Reserved Instances, you purchase the right to launch instances for a period of time. During that time period, you do not receive insufficient capacity errors, and you pay a lower usage rate than the rate charged for OnDemand instances for the a... | def describe_reserved_instances_offerings(DryRun=None, ReservedInstancesOfferingIds=None, InstanceType=None, AvailabilityZone=None, ProductDescription=None, Filters=None, InstanceTenancy=None, OfferingType=None, NextToken=None, MaxResults=None, IncludeMarketplace=None, MinDuration=None, MaxDuration=None, MaxInstanceCou... | [
"def describe_reserved_instances(DryRun=None, ReservedInstancesIds=None, Filters=None, OfferingType=None, OfferingClass=None):\n pass",
"def getReservedInstances(verbose):\n lres = {}\n jResp = EC2C.describe_reserved_instances()\n for reserved in jResp['ReservedInstances']:\n if reserved['State... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Describes one or more of your route tables. Each subnet in your VPC must be associated with a route table. If a subnet is not explicitly associated with any route table, it is implicitly associated with the main route table. This command does not return the subnet ID for implicit associations. For more information abou... | def describe_route_tables(DryRun=None, RouteTableIds=None, Filters=None):
pass | [
"def describe_route_tables(\n route_table_id=None,\n route_table_name=None,\n vpc_id=None,\n tags=None,\n region=None,\n key=None,\n keyid=None,\n profile=None,\n):\n\n if not any((route_table_id, route_table_name, tags, vpc_id)):\n raise SaltInvocationError(\n \"At leas... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Describes one or more of your Scheduled Instances. | def describe_scheduled_instances(DryRun=None, ScheduledInstanceIds=None, SlotStartTimeRange=None, NextToken=None, MaxResults=None, Filters=None):
pass | [
"def describe(self):\n print(Controller().describe_instances())",
"def run_scheduled_instances(DryRun=None, ClientToken=None, InstanceCount=None, ScheduledInstanceId=None, LaunchSpecification=None):\n pass",
"def report_instance_status(DryRun=None, Instances=None, Status=None, StartTime=None, EndTime=... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Describes one or more of your security groups. A security group is for use with instances either in the EC2Classic platform or in a specific VPC. For more information, see Amazon EC2 Security Groups in the Amazon Elastic Compute Cloud User Guide and Security Groups for Your VPC in the Amazon Virtual Private Cloud User ... | def describe_security_groups(DryRun=None, GroupNames=None, GroupIds=None, Filters=None):
pass | [
"def getsecuritygroups(show):\n securitygrouplist=[]\n \n try:\n securitygroups=ec2.describe_security_groups()\n except botocore.exceptions.ClientError as e:\n coloredtext(\"There was an error while getting security group data: \\n\\n\\n\")\n print(e)\n fo... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Describes the specified attribute of the specified snapshot. You can specify only one attribute at a time. For more information about EBS snapshots, see Amazon EBS Snapshots in the Amazon Elastic Compute Cloud User Guide . | def describe_snapshot_attribute(DryRun=None, SnapshotId=None, Attribute=None):
pass | [
"def modify_snapshot_attribute(DryRun=None, SnapshotId=None, Attribute=None, OperationType=None, UserIds=None, GroupNames=None, CreateVolumePermission=None):\n pass",
"def setSnapshotAttribute(self, snapshot: 'char const *') -> \"void\":\n return _coin.ScXMLAnchorElt_setSnapshotAttribute(self, snapshot)... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Describes one or more of the EBS snapshots available to you. Available snapshots include public snapshots available for any AWS account to launch, private snapshots that you own, and private snapshots owned by another AWS account but for which you've been given explicit create volume permissions. | def describe_snapshots(DryRun=None, SnapshotIds=None, OwnerIds=None, RestorableByUserIds=None, Filters=None, NextToken=None, MaxResults=None):
pass | [
"def list_snapshots(self):\r\n return self._snapshot_manager.list()",
"def snapshots_list(self, stack_name, ext_id):\n \n path=\"/stacks/%s/%s/snapshots\"%(stack_name,ext_id)\n if stack_name is not None and ext_id is not None:\n res = self.client.call(path, 'GET', data='', t... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Describes the data feed for Spot instances. For more information, see Spot Instance Data Feed in the Amazon Elastic Compute Cloud User Guide . | def describe_spot_datafeed_subscription(DryRun=None):
pass | [
"def describe_spot_fleet_instances(DryRun=None, SpotFleetRequestId=None, NextToken=None, MaxResults=None):\n pass",
"def describe_spot_instance_requests(DryRun=None, SpotInstanceRequestIds=None, Filters=None):\n pass",
"def create_spot_instance(config, job_id, sched_time, docker_image, env_vars):\n\n c... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Describes the running instances for the specified Spot fleet. | def describe_spot_fleet_instances(DryRun=None, SpotFleetRequestId=None, NextToken=None, MaxResults=None):
pass | [
"def showinstances():\n username, conn = _getbotoconn(auth_user)\n\n print \"all instances running under the %s account\" % username\n\n num_running = 0\n reservations = conn.get_all_instances()\n for reservation in reservations:\n num_running += _print_reservation(reservation)\n\n return n... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Describes the events for the specified Spot fleet request during the specified time. Spot fleet events are delayed by up to 30 seconds before they can be described. This ensures that you can query by the last evaluated time and not miss a recorded event. | def describe_spot_fleet_request_history(DryRun=None, SpotFleetRequestId=None, EventType=None, StartTime=None, NextToken=None, MaxResults=None):
pass | [
"def events_after(self, events, time):\n relevant_logs = [log_time for log_time in events\n if log_time > time]\n return dict((logtime, events[logtime]) for logtime in relevant_logs)",
"def describe_spot_fleet_requests(DryRun=None, SpotFleetRequestIds=None, NextToken... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Describes your Spot fleet requests. Spot fleet requests are deleted 48 hours after they are canceled and their instances are terminated. | def describe_spot_fleet_requests(DryRun=None, SpotFleetRequestIds=None, NextToken=None, MaxResults=None):
pass | [
"def describe_spot_instance_requests(DryRun=None, SpotInstanceRequestIds=None, Filters=None):\n pass",
"def describe_spot_fleet_request_history(DryRun=None, SpotFleetRequestId=None, EventType=None, StartTime=None, NextToken=None, MaxResults=None):\n pass",
"def help_list_requests():\n get_list_ride... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Describes the Spot instance requests that belong to your account. Spot instances are instances that Amazon EC2 launches when the bid price that you specify exceeds the current Spot price. Amazon EC2 periodically sets the Spot price based on available Spot instance capacity and current Spot instance requests. For more i... | def describe_spot_instance_requests(DryRun=None, SpotInstanceRequestIds=None, Filters=None):
pass | [
"def request_spot_instances(DryRun=None, SpotPrice=None, ClientToken=None, InstanceCount=None, Type=None, ValidFrom=None, ValidUntil=None, LaunchGroup=None, AvailabilityZoneGroup=None, BlockDurationMinutes=None, LaunchSpecification=None):\n pass",
"def describe_spot_fleet_instances(DryRun=None, SpotFleetReques... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Describes the Spot price history. For more information, see Spot Instance Pricing History in the Amazon Elastic Compute Cloud User Guide . When you specify a start and end time, this operation returns the prices of the instance types within the time range that you specified and the time when the price changed. The pric... | def describe_spot_price_history(DryRun=None, StartTime=None, EndTime=None, InstanceTypes=None, ProductDescriptions=None, Filters=None, AvailabilityZone=None, MaxResults=None, NextToken=None):
pass | [
"def get_spot_price(instance_type, region_name):\n ec2_client = boto3.client('ec2', region_name=region_name)\n response = ec2_client.describe_spot_price_history(\n InstanceTypes=[instance_type],\n ProductDescriptions=['Linux/UNIX'],\n MaxResults=1)\n\n spot_price = response['SpotPriceH... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
[EC2VPC only] Describes the stale security group rules for security groups in a specified VPC. Rules are stale when they reference a deleted security group in a peer VPC, or a security group in a peer VPC for which the VPC peering connection has been deleted. | def describe_stale_security_groups(DryRun=None, VpcId=None, MaxResults=None, NextToken=None):
pass | [
"def vpc_classic_link_security_groups(self) -> Sequence[str]:\n warnings.warn(\"\"\"With the retirement of EC2-Classic the vpc_classic_link_security_groups attribute has been deprecated and will be removed in a future version.\"\"\", DeprecationWarning)\n pulumi.log.warn(\"\"\"vpc_classic_link_securit... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Describes the specified attribute of the specified volume. You can specify only one attribute at a time. For more information about EBS volumes, see Amazon EBS Volumes in the Amazon Elastic Compute Cloud User Guide . | def describe_volume_attribute(DryRun=None, VolumeId=None, Attribute=None):
pass | [
"def showattribute(self, vname=None, device=None):\n if device is None:\n device = sys.stdout\n if vname is None:\n vname = self.default_variable_name\n device.write(\"Attributes of \")\n device.write(vname)\n device.write(\" in file \")\n device.write... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Describes the status of the specified volumes. Volume status provides the result of the checks performed on your volumes to determine events that can impair the performance of your volumes. The performance of a volume can be affected if an issue occurs on the volume's underlying host. If the volume's underlying host ex... | def describe_volume_status(DryRun=None, VolumeIds=None, Filters=None, NextToken=None, MaxResults=None):
pass | [
"def volume_status(self, volume):\r\n volume = self._get_volume(volume)\r\n raid = self._get_raid(volume[\"devicefile\"])\r\n if volume is not None and raid is not None:\r\n return raid[\"state\"]",
"def volume_status(mnode, volname):\n return RestClient(mnode).handle_request(\n... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Describes the specified EBS volumes. If you are describing a long list of volumes, you can paginate the output to make the list more manageable. The MaxResults parameter sets the maximum number of results returned in a single page. If the list of results exceeds your MaxResults value, then that number of results is ret... | def describe_volumes(DryRun=None, VolumeIds=None, Filters=None, NextToken=None, MaxResults=None):
pass | [
"def list(self,\n **kwargs\n ):\n\n # dont filter_name=None,\n # dont filter_value=None,\n # dryrun=False):\n\n #:param filter_name (string)\n #:param filter_value (string)\n #:param volume_ids (list): The volume IDs\n\n # filter = \... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Reports the current modification status of EBS volumes. Currentgeneration EBS volumes support modification of attributes including type, size, and (for io1 volumes) IOPS provisioning while either attached to or detached from an instance. Following an action from the API or the console to modify a volume, the status of ... | def describe_volumes_modifications(DryRun=None, VolumeIds=None, Filters=None, NextToken=None, MaxResults=None):
pass | [
"def volume_status(mnode, volname):\n return RestClient(mnode).handle_request(\n \"GET\", \"/v1/volumes/%s/status\" % volname,\n httplib.OK, None)",
"def describe_volume_status(DryRun=None, VolumeIds=None, Filters=None, NextToken=None, MaxResults=None):\n pass",
"def volume_status(se... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Describes the specified attribute of the specified VPC. You can specify only one attribute at a time. | def describe_vpc_attribute(DryRun=None, VpcId=None, Attribute=None):
pass | [
"def describe_attr_value(attr, die, section_offset):\r\n descr_func = _ATTR_DESCRIPTION_MAP[attr.form]\r\n val_description = descr_func(attr, die, section_offset)\r\n\r\n # For some attributes we can display further information\r\n extra_info_func = _EXTRA_INFO_DESCRIPTION_MAP[attr.name]\r\n extra_in... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Describes the ClassicLink status of one or more VPCs. | def describe_vpc_classic_link(DryRun=None, VpcIds=None, Filters=None):
pass | [
"def getvpcs(show):\n vpclist=[]\n \n try:\n vpcs=ec2.describe_vpcs()\n except botocore.exceptions.ClientError as e:\n coloredtext(\"There was an error while getting vpc data: \\n\\n\\n\")\n print(e)\n for vpc in vpcs['Vpcs']:\n name=vpc['VpcId']\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Describes the ClassicLink DNS support status of one or more VPCs. If enabled, the DNS hostname of a linked EC2Classic instance resolves to its private IP address when addressed from an instance in the VPC to which it's linked. Similarly, the DNS hostname of an instance in a VPC resolves to its private IP address when a... | def describe_vpc_classic_link_dns_support(VpcIds=None, MaxResults=None, NextToken=None):
pass | [
"def describe_vpc_classic_link(DryRun=None, VpcIds=None, Filters=None):\n pass",
"def test_dnssec_available():\n response = zone.dnssec_available('example.com')\n assert response.success\n\n payload = response.payload\n assert payload['url'] == 'https://api.cloudns.net/dns/is-dnssec-available.json'... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Describes all supported AWS services that can be specified when creating a VPC endpoint. | def describe_vpc_endpoint_services(DryRun=None, MaxResults=None, NextToken=None):
pass | [
"def aws_services(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['AssessmentAwsServiceArgs']]]]:\n return pulumi.get(self, \"aws_services\")",
"def _add_services(self):\n this_service = {'name': 'designate'}\n other_services = [\n {'name': 'percona-cluster', 'constraints': {'... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Describes one or more of your VPC endpoints. | def describe_vpc_endpoints(DryRun=None, VpcEndpointIds=None, Filters=None, MaxResults=None, NextToken=None):
pass | [
"def describe_vpc_endpoint_services(DryRun=None, MaxResults=None, NextToken=None):\n pass",
"def delete_vpc_endpoint_resources():\n print('Deleting VPC endpoints')\n ec2 = boto3.client('ec2')\n endpoint_ids = []\n for endpoint in ec2.describe_vpc_endpoints()['VpcEndpoints']:\n print('Deletin... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Describes one or more of your VPC peering connections. | def describe_vpc_peering_connections(DryRun=None, VpcPeeringConnectionIds=None, Filters=None):
pass | [
"def describe_vpc_peering_connection(\n name, region=None, key=None, keyid=None, profile=None\n):\n conn = _get_conn3(region=region, key=key, keyid=keyid, profile=profile)\n return {\"VPC-Peerings\": _get_peering_connection_ids(name, conn)}",
"def describe_vpn_connections(DryRun=None, VpnConnectionIds=No... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Describes one or more of your VPCs. | def describe_vpcs(DryRun=None, VpcIds=None, Filters=None):
pass | [
"def describe(\n vpc_id=None,\n vpc_name=None,\n region=None,\n key=None,\n keyid=None,\n profile=None,\n):\n\n try:\n conn = _get_conn(region=region, key=key, keyid=keyid, profile=profile)\n vpc_id = _find_vpcs(\n vpc_id=vpc_id,\n vpc_name=vpc_name,\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Describes one or more of your VPN connections. For more information about VPN connections, see Adding a Hardware Virtual Private Gateway to Your VPC in the Amazon Virtual Private Cloud User Guide . | def describe_vpn_connections(DryRun=None, VpnConnectionIds=None, Filters=None):
pass | [
"def listVpnConnection(cls, api_client, **kwargs):\n cmd = {}\n cmd.update(kwargs)\n return super(Vpn, cls).list(api_client.listVpnConnections(**cmd).get('vpnconnection', []))",
"def describe_vpc_peering_connections(DryRun=None, VpcPeeringConnectionIds=None, Filters=None):\n pass",
"def ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Describes one or more of your virtual private gateways. For more information about virtual private gateways, see Adding an IPsec Hardware VPN to Your VPC in the Amazon Virtual Private Cloud User Guide . | def describe_vpn_gateways(DryRun=None, VpnGatewayIds=None, Filters=None):
pass | [
"def delete_virtual_gateways():\n client = boto3.client('ec2')\n print('Deleting VPN Gateways')\n gw_resp = client.describe_vpn_gateways()\n while True:\n for gateway in gw_resp['VpnGateways']:\n gw_id = gateway['VpnGatewayId']\n gw_attachments = gateway['VpcAttachments']\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Unlinks (detaches) a linked EC2Classic instance from a VPC. After the instance has been unlinked, the VPC security groups are no longer associated with it. An instance is automatically unlinked from a VPC when it's stopped. | def detach_classic_link_vpc(DryRun=None, InstanceId=None, VpcId=None):
pass | [
"def terminate_instance(instance_id):\n\n client = boto3.client('ec2')\n response = client.terminate_instances(InstanceIds=instance_id)",
"def terminate(session):\n logging.info(\"Terminating instances\")\n session.clients[\"ec2\"].terminate_instances(InstanceIds=list(session.instances))",
"def Term... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Detaches an Internet gateway from a VPC, disabling connectivity between the Internet and the VPC. The VPC must not contain any running instances with Elastic IP addresses or public IPv4 addresses. | def detach_internet_gateway(DryRun=None, InternetGatewayId=None, VpcId=None):
pass | [
"def delete_internet_gateways():\n print('Deleting Internet Gateways')\n client = boto3.resource('ec2')\n for igw in client.internet_gateways.all():\n for attachment in igw.attachments:\n if 'State' in attachment and attachment['State'] == 'available':\n vpc_id = attachment... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Detaches an EBS volume from an instance. Make sure to unmount any file systems on the device within your operating system before detaching the volume. Failure to do so can result in the volume becoming stuck in the busy state while detaching. If this happens, detachment can be delayed indefinitely until you unmount the... | def detach_volume(DryRun=None, VolumeId=None, InstanceId=None, Device=None, Force=None):
pass | [
"def detach_volume(self, instance_name, mountpoint):\n\n # Find the instance ref so we can pass it to the\n # _container_script_modify method.\n meta = self._find_by_name(instance_name)\n instance = db.instance_get(context.get_admin_context(), meta['id'])\n self._container_script_... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Detaches a virtual private gateway from a VPC. You do this if you're planning to turn off the VPC and not use it anymore. You can confirm a virtual private gateway has been completely detached from a VPC by describing the virtual private gateway (any attachments to the virtual private gateway are also described). You m... | def detach_vpn_gateway(DryRun=None, VpnGatewayId=None, VpcId=None):
pass | [
"def Detach(self):\n detach_cmd = [FLAGS.gcloud_path,\n 'compute',\n 'instances',\n 'detach-disk',\n self.attached_vm_name,\n '--device-name', self.name]\n detach_cmd.extend(util.GetDefaultGcloudFlags(self))\n vm_util.Issu... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Disables a virtual private gateway (VGW) from propagating routes to a specified route table of a VPC. | def disable_vgw_route_propagation(RouteTableId=None, GatewayId=None):
pass | [
"def enable_vgw_route_propagation(RouteTableId=None, GatewayId=None):\n pass",
"def delete_virtual_gateways():\n client = boto3.client('ec2')\n print('Deleting VPN Gateways')\n gw_resp = client.describe_vpn_gateways()\n while True:\n for gateway in gw_resp['VpnGateways']:\n gw_id ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Disables ClassicLink for a VPC. You cannot disable ClassicLink for a VPC that has EC2Classic instances linked to it. | def disable_vpc_classic_link(DryRun=None, VpcId=None):
pass | [
"def attach_classic_link_vpc(DryRun=None, InstanceId=None, VpcId=None, Groups=None):\n pass",
"def describe_vpc_classic_link(DryRun=None, VpcIds=None, Filters=None):\n pass",
"def disable_catalog_allow_links(self, catalog_id):\r\n\r\n logging.info(\"Disabling catalog links for catalog: '\"+catalog_... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Disables ClassicLink DNS support for a VPC. If disabled, DNS hostnames resolve to public IP addresses when addressed between a linked EC2Classic instance and instances in the VPC to which it's linked. For more information about ClassicLink, see ClassicLink in the Amazon Elastic Compute Cloud User Guide . | def disable_vpc_classic_link_dns_support(VpcId=None):
pass | [
"def describe_vpc_classic_link_dns_support(VpcIds=None, MaxResults=None, NextToken=None):\n pass",
"def modify_vpc_attribute(VpcId=None, EnableDnsSupport=None, EnableDnsHostnames=None):\n pass",
"def attach_classic_link_vpc(DryRun=None, InstanceId=None, VpcId=None, Groups=None):\n pass",
"def disable... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Disassociates an Elastic IP address from the instance or network interface it's associated with. An Elastic IP address is for use in either the EC2Classic platform or in a VPC. For more information, see Elastic IP Addresses in the Amazon Elastic Compute Cloud User Guide . This is an idempotent operation. If you perform... | def disassociate_address(DryRun=None, PublicIp=None, AssociationId=None):
pass | [
"def disassociate_address(self, address):\n query = self.query_factory(\n action=\"DisassociateAddress\", creds=self.creds,\n endpoint=self.endpoint, other_params={\"PublicIp\": address})\n d = query.submit()\n return d.addCallback(self.parser.truth_return)",
"def HaVipD... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Disassociates an IAM instance profile from a running or stopped instance. Use DescribeIamInstanceProfileAssociations to get the association ID. | def disassociate_iam_instance_profile(AssociationId=None):
pass | [
"def delete_profile(self):\n response = self.client.delete_instance_profile(\n InstanceProfileName=self.ProfileName\n )",
"def TerminateInstance(*, session, instanceid):\n ec2conn = session.connect_to(\"ec2\")\n return ec2conn.terminate_instances(instance_ids=[instanceid,])",
"def delete_... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Disassociates a subnet from a route table. After you perform this action, the subnet no longer uses the routes in the route table. Instead, it uses the routes in the VPC's main route table. For more information about route tables, see Route Tables in the Amazon Virtual Private Cloud User Guide . | def disassociate_route_table(DryRun=None, AssociationId=None):
pass | [
"def disassociate_address(DryRun=None, PublicIp=None, AssociationId=None):\n pass",
"def disassociate_network_acl(\n subnet_id=None,\n vpc_id=None,\n subnet_name=None,\n vpc_name=None,\n region=None,\n key=None,\n keyid=None,\n profile=None,\n):\n\n if not _exactly_one((subnet_name, ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Disassociates a CIDR block from a subnet. Currently, you can disassociate an IPv6 CIDR block only. You must detach or delete all gateways and resources that are associated with the CIDR block before you can disassociate it. | def disassociate_subnet_cidr_block(AssociationId=None):
pass | [
"def disassociate_address(DryRun=None, PublicIp=None, AssociationId=None):\n pass",
"def UnassignIpv6CidrBlock(self, request):\n try:\n params = request._serialize()\n headers = request.headers\n body = self.call(\"UnassignIpv6CidrBlock\", params, headers=headers)\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Disassociates a CIDR block from a VPC. Currently, you can disassociate an IPv6 CIDR block only. You must detach or delete all gateways and resources that are associated with the CIDR block before you can disassociate it. | def disassociate_vpc_cidr_block(AssociationId=None):
pass | [
"def disassociate_address(DryRun=None, PublicIp=None, AssociationId=None):\n pass",
"def UnassignIpv6CidrBlock(self, request):\n try:\n params = request._serialize()\n headers = request.headers\n body = self.call(\"UnassignIpv6CidrBlock\", params, headers=headers)\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Enables a virtual private gateway (VGW) to propagate routes to the specified route table of a VPC. | def enable_vgw_route_propagation(RouteTableId=None, GatewayId=None):
pass | [
"def configure_routing(vpc):\n internet_gateways = list(vpc.internet_gateways.all())\n if len(internet_gateways) == 1:\n internet_gateway = internet_gateways[0]\n elif len(internet_gateways) == 0:\n raise CraftingTableError(\"No internet gateway found\")\n else:\n raise CraftingTabl... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Enables I/O operations for a volume that had I/O operations disabled because the data on the volume was potentially inconsistent. | def enable_volume_io(DryRun=None, VolumeId=None):
pass | [
"def modify_volume_attribute(DryRun=None, VolumeId=None, AutoEnableIO=None):\n pass",
"def toggleControl_AOFile(self):\n\n self.Voltage_ReadFromFile = True\n self.Voltage_Input.setDisabled(True)",
"def enable(self):\n for volume in self.volumes:\n try:\n self._r... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Enables a VPC for ClassicLink. You can then link EC2Classic instances to your ClassicLinkenabled VPC to allow communication over private IP addresses. You cannot enable your VPC for ClassicLink if any of your VPC's route tables have existing routes for address ranges within the 10.0.0.0/8 IP address range, excluding lo... | def enable_vpc_classic_link(DryRun=None, VpcId=None):
pass | [
"def attach_classic_link_vpc(DryRun=None, InstanceId=None, VpcId=None, Groups=None):\n pass",
"def describe_vpc_classic_link(DryRun=None, VpcIds=None, Filters=None):\n pass",
"def describe_vpc_classic_link_dns_support(VpcIds=None, MaxResults=None, NextToken=None):\n pass",
"def configure_routing(vpc)... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Enables a VPC to support DNS hostname resolution for ClassicLink. If enabled, the DNS hostname of a linked EC2Classic instance resolves to its private IP address when addressed from an instance in the VPC to which it's linked. Similarly, the DNS hostname of an instance in a VPC resolves to its private IP address when a... | def enable_vpc_classic_link_dns_support(VpcId=None):
pass | [
"def describe_vpc_classic_link_dns_support(VpcIds=None, MaxResults=None, NextToken=None):\n pass",
"def setup_dns(self, instance_identifier):\n start_time = time.time()\n instance_endpoint = keep_trying(RDS_STARTUP_TIMEOUT, self._get_instance_address, instance_identifier)\n logging.info(\"... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Preview a reservation purchase with configurations that match those of your Dedicated Host. You must have active Dedicated Hosts in your account before you purchase a reservation. This is a preview of the PurchaseHostReservation action and does not result in the offering being purchased. | def get_host_reservation_purchase_preview(OfferingId=None, HostIdSet=None):
pass | [
"def purchase_host_reservation(OfferingId=None, HostIdSet=None, LimitPrice=None, CurrencyCode=None, ClientToken=None):\n pass",
"def describe_host_reservations(HostReservationIdSet=None, Filters=None, MaxResults=None, NextToken=None):\n pass",
"def describe_host_reservation_offerings(OfferingId=None, MinD... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Import single or multivolume disk images or EBS snapshots into an Amazon Machine Image (AMI). For more information, see Importing a VM as an Image Using VM Import/Export in the VM Import/Export User Guide . | def import_image(DryRun=None, Description=None, DiskContainers=None, LicenseType=None, Hypervisor=None, Architecture=None, Platform=None, ClientData=None, ClientToken=None, RoleName=None):
pass | [
"def import_instance(DryRun=None, Description=None, LaunchSpecification=None, DiskImages=None, Platform=None):\n pass",
"def image_import(self, image_name, url, image_meta, remote_host=None):\n image_info = []\n try:\n image_info = self._ImageDbOperator.image_query_record(image_name)\n... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Creates an import instance task using metadata from the specified disk image. ImportInstance only supports singlevolume VMs. To import multivolume VMs, use ImportImage . For more information, see Importing a Virtual Machine Using the Amazon EC2 CLI . For information about the import manifest referenced by this API acti... | def import_instance(DryRun=None, Description=None, LaunchSpecification=None, DiskImages=None, Platform=None):
pass | [
"def import_task(self, img, cont, img_format=None, img_name=None):\r\n return self._tasks_manager.create(\"import\", img=img, cont=cont,\r\n img_format=img_format, img_name=img_name)",
"def import_image(DryRun=None, Description=None, DiskContainers=None, LicenseType=None, Hypervisor=None, Ar... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Imports the public key from an RSA key pair that you created with a thirdparty tool. Compare this with CreateKeyPair , in which AWS creates the key pair and gives the keys to you (AWS keeps a copy of the public key). With ImportKeyPair, you create the key pair and give AWS just the public key. The private key is never ... | def import_key_pair(DryRun=None, KeyName=None, PublicKeyMaterial=None):
pass | [
"def import_keypair(self, keypair: str) -> None:\n try:\n assert type(keypair) == str\n except AssertionError:\n print(\"Keypair not of type Str.\")\n return\n\n try:\n assert len(keypair) == 88\n except AssertionError:\n print(\"Key... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Imports a disk into an EBS snapshot. | def import_snapshot(DryRun=None, Description=None, DiskContainer=None, ClientData=None, ClientToken=None, RoleName=None):
pass | [
"def test_copy_vm_disks_with_snapshot(self, storage):\n testflow.step(\"Taking snapshot of VM %s\", self.vm_name)\n assert ll_vms.addSnapshot(\n True, self.vm_name, self.snapshot_description\n ), (\"Failed to create snapshot for vm %s\" % self.vm_name)\n ll_jobs.wait_for_jobs(... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Modify the autoplacement setting of a Dedicated Host. When autoplacement is enabled, AWS will place instances that you launch with a tenancy of host , but without targeting a specific host ID, onto any available Dedicated Host in your account which has autoplacement enabled. When autoplacement is disabled, you need to ... | def modify_hosts(HostIds=None, AutoPlacement=None):
pass | [
"def modify_instance_placement(InstanceId=None, Tenancy=None, Affinity=None, HostId=None):\n pass",
"def enable_dhcp(self, ip_host_num):\n return [\"ip-host %s dhcp-enable true ping-response true traceroute-response true\" % ip_host_num]",
"def host(self, value):\n if self._host:\n r... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Modifies the ID format of a resource for a specified IAM user, IAM role, or the root user for an account; or all IAM users, IAM roles, and the root user for an account. You can specify that resources should receive longer IDs (17character IDs) when they are created. | def modify_identity_id_format(Resource=None, UseLongIds=None, PrincipalArn=None):
pass | [
"def update_resource(\n self,\n education_user_id, # type: str\n education_assignment_id, # type: str\n education_assignment_resource_id, # type: str\n id=None, # type: Optional[str]\n distribute_for_student_work=None, # type: Optional[bool]\n created_date_time=... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Modifies the specified attribute of the specified AMI. You can specify only one attribute at a time. | def modify_image_attribute(DryRun=None, ImageId=None, Attribute=None, OperationType=None, UserIds=None, UserGroups=None, ProductCodes=None, Value=None, LaunchPermission=None, Description=None):
pass | [
"def update(self, attribute, data):\n return self.call('catalog_product_attribute.update', [attribute, data])",
"def modify_snapshot_attribute(DryRun=None, SnapshotId=None, Attribute=None, OperationType=None, UserIds=None, GroupNames=None, CreateVolumePermission=None):\n pass",
"def modify_instance_at... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Modifies the specified attribute of the specified instance. You can specify only one attribute at a time. To modify some attributes, the instance must be stopped. For more information, see Modifying Attributes of a Stopped Instance in the Amazon Elastic Compute Cloud User Guide . | def modify_instance_attribute(DryRun=None, InstanceId=None, Attribute=None, Value=None, BlockDeviceMappings=None, SourceDestCheck=None, DisableApiTermination=None, InstanceType=None, Kernel=None, Ramdisk=None, UserData=None, InstanceInitiatedShutdownBehavior=None, Groups=None, EbsOptimized=None, SriovNetSupport=None, E... | [
"def reset_instance_attribute(DryRun=None, InstanceId=None, Attribute=None):\n pass",
"def set_attr_2(self, value):\r\n arg_str = p2e._base._util._convert_args_to_string(\"set.object.attr2\", self._object._eco_id, value)\r\n p2e._app.Exec(arg_str)",
"def update(self, attr):\n assert ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Set the instance affinity value for a specific stopped instance and modify the instance tenancy setting. Instance affinity is disabled by default. When instance affinity is host and it is not associated with a specific Dedicated Host, the next time it is launched it will automatically be associated with the host it lan... | def modify_instance_placement(InstanceId=None, Tenancy=None, Affinity=None, HostId=None):
pass | [
"def modify_instance_attribute(DryRun=None, InstanceId=None, Attribute=None, Value=None, BlockDeviceMappings=None, SourceDestCheck=None, DisableApiTermination=None, InstanceType=None, Kernel=None, Ramdisk=None, UserData=None, InstanceInitiatedShutdownBehavior=None, Groups=None, EbsOptimized=None, SriovNetSupport=No... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Modifies the specified network interface attribute. You can specify only one attribute at a time. | def modify_network_interface_attribute(DryRun=None, NetworkInterfaceId=None, Description=None, SourceDestCheck=None, Groups=None, Attachment=None):
pass | [
"def ModifyNetworkInterfaceAttribute(self, request):\n try:\n params = request._serialize()\n headers = request.headers\n body = self.call(\"ModifyNetworkInterfaceAttribute\", params, headers=headers)\n response = json.loads(body)\n model = models.Modify... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Modifies the Availability Zone, instance count, instance type, or network platform (EC2Classic or EC2VPC) of your Standard Reserved Instances. The Reserved Instances to be modified must be identical, except for Availability Zone, network platform, and instance type. For more information, see Modifying Reserved Instance... | def modify_reserved_instances(ClientToken=None, ReservedInstancesIds=None, TargetConfigurations=None):
pass | [
"def modify_instance_placement(InstanceId=None, Tenancy=None, Affinity=None, HostId=None):\n pass",
"def modify_instance_attribute(DryRun=None, InstanceId=None, Attribute=None, Value=None, BlockDeviceMappings=None, SourceDestCheck=None, DisableApiTermination=None, InstanceType=None, Kernel=None, Ramdisk=None, ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Adds or removes permission settings for the specified snapshot. You may add or remove specified AWS account IDs from a snapshot's list of create volume permissions, but you cannot do both in a single API call. If you need to both add and remove account IDs for a snapshot, you must use multiple API calls. For more infor... | def modify_snapshot_attribute(DryRun=None, SnapshotId=None, Attribute=None, OperationType=None, UserIds=None, GroupNames=None, CreateVolumePermission=None):
pass | [
"def modify_snap_access_mode(self, snapshot_id, snap_access_mode):\n\n try:\n self.powerflex_conn.volume.set_volume_access_mode_limit(\n volume_id=snapshot_id, access_mode_limit=snap_access_mode)\n return True\n except Exception as e:\n errormsg = \"Modi... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Modifies the specified Spot fleet request. While the Spot fleet request is being modified, it is in the modifying state. To scale up your Spot fleet, increase its target capacity. The Spot fleet launches the additional Spot instances according to the allocation strategy for the Spot fleet request. If the allocation str... | def modify_spot_fleet_request(SpotFleetRequestId=None, TargetCapacity=None, ExcessCapacityTerminationPolicy=None):
pass | [
"def update_request():",
"def put(self, request, *args, **kwargs):\n\n data = request.DATA\n json_validate(SPECS.get('equipment_put')).validate(data)\n response = facade.update_equipment(data['equipments'], request.user)\n\n return Response(response, status=status.HTTP_200_OK)",
"def... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Modifies a subnet attribute. You can only modify one attribute at a time. | def modify_subnet_attribute(SubnetId=None, MapPublicIpOnLaunch=None, AssignIpv6AddressOnCreation=None):
pass | [
"def update_subnet(self, request):",
"def update_subnet(self, context, _id, subnet):\n t_ctx = t_context.get_context_from_neutron_context(context)\n b_subnet = self.core_plugin.get_subnet(context, _id)\n origin_enable_dhcp = b_subnet['enable_dhcp']\n req_enable_dhcp = subnet['subnet'][... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
You can modify several parameters of an existing EBS volume, including volume size, volume type, and IOPS capacity. If your EBS volume is attached to a currentgeneration EC2 instance type, you may be able to apply these changes without stopping the instance or detaching the volume from it. For more information about mo... | def modify_volume(DryRun=None, VolumeId=None, Size=None, VolumeType=None, Iops=None):
pass | [
"def _extend_volume(self, name, new_size):\n LOG.debug('_extend__volume name: %s', name)\n params = {}\n params['volsize'] = ix_utils.get_bytes_from_gb(new_size)\n jparams = json.dumps(params)\n jparams = jparams.encode('utf8')\n request_urn = ('%s/id/%s') % (\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Modifies a volume attribute. By default, all I/O operations for the volume are suspended when the data on the volume is determined to be potentially inconsistent, to prevent undetectable, latent data corruption. The I/O access to the volume can be resumed by first enabling I/O access and then checking the data consiste... | def modify_volume_attribute(DryRun=None, VolumeId=None, AutoEnableIO=None):
pass | [
"def modify_snapshot_attribute(DryRun=None, SnapshotId=None, Attribute=None, OperationType=None, UserIds=None, GroupNames=None, CreateVolumePermission=None):\n pass",
"async def async_api_adjust_volume(\n hass: ha.HomeAssistant,\n config: AbstractConfig,\n directive: AlexaDirective,\n context: ha.C... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Modifies the specified attribute of the specified VPC. | def modify_vpc_attribute(VpcId=None, EnableDnsSupport=None, EnableDnsHostnames=None):
pass | [
"def ModifyVpcEndPointServiceAttribute(self, request):\n try:\n params = request._serialize()\n headers = request.headers\n body = self.call(\"ModifyVpcEndPointServiceAttribute\", params, headers=headers)\n response = json.loads(body)\n model = models.Mo... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Modifies attributes of a specified VPC endpoint. You can modify the policy associated with the endpoint, and you can add and remove route tables associated with the endpoint. | def modify_vpc_endpoint(DryRun=None, VpcEndpointId=None, ResetPolicy=None, PolicyDocument=None, AddRouteTableIds=None, RemoveRouteTableIds=None):
pass | [
"def ModifyVpcEndPointServiceAttribute(self, request):\n try:\n params = request._serialize()\n headers = request.headers\n body = self.call(\"ModifyVpcEndPointServiceAttribute\", params, headers=headers)\n response = json.loads(body)\n model = models.Mo... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Moves an Elastic IP address from the EC2Classic platform to the EC2VPC platform. The Elastic IP address must be allocated to your account for more than 24 hours, and it must not be associated with an instance. After the Elastic IP address is moved, it is no longer available for use in the EC2Classic platform, unless yo... | def move_address_to_vpc(DryRun=None, PublicIp=None):
pass | [
"def restore_address_to_classic(DryRun=None, PublicIp=None):\n pass",
"def ElasticIps(self, zone = None):\n if zone is None:\n zone = self.zone\n self.reservation = self.tester.run_instance(keypair=self.keypair.name, group=self.group.name)\n self.tester.sleep(10)\n for in... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Purchase a reservation with configurations that match those of your Dedicated Host. You must have active Dedicated Hosts in your account before you purchase a reservation. This action results in the specified reservation being purchased and charged to your account. | def purchase_host_reservation(OfferingId=None, HostIdSet=None, LimitPrice=None, CurrencyCode=None, ClientToken=None):
pass | [
"def attemptPurchases(order):\n print(\"\\n\")\n # here we sort out the availability zones\n hasOrdersAssigned = True\n\n for az in order.AvailabilityZones:\n if az.ordered is None:\n az.ordered = 0\n if az.Number is None:\n hasOrdersAssigned = False\n\n if hasOrde... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Purchases a Reserved Instance for use with your account. With Reserved Instances, you pay a lower hourly rate compared to OnDemand instance pricing. Use DescribeReservedInstancesOfferings to get a list of Reserved Instance offerings that match your specifications. After you've purchased a Reserved Instance, you can che... | def purchase_reserved_instances_offering(DryRun=None, ReservedInstancesOfferingId=None, InstanceCount=None, LimitPrice=None):
pass | [
"def create_reserved_instances_listing(ReservedInstancesId=None, InstanceCount=None, PriceSchedules=None, ClientToken=None):\n pass",
"def describe_reserved_instances_offerings(DryRun=None, ReservedInstancesOfferingIds=None, InstanceType=None, AvailabilityZone=None, ProductDescription=None, Filters=None, Insta... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Purchases one or more Scheduled Instances with the specified schedule. Scheduled Instances enable you to purchase Amazon EC2 compute capacity by the hour for a oneyear term. Before you can purchase a Scheduled Instance, you must call DescribeScheduledInstanceAvailability to check for available schedules and obtain a pu... | def purchase_scheduled_instances(DryRun=None, ClientToken=None, PurchaseRequests=None):
pass | [
"def run_scheduled_instances(DryRun=None, ClientToken=None, InstanceCount=None, ScheduledInstanceId=None, LaunchSpecification=None):\n pass",
"def create_reserved_instances_listing(ReservedInstancesId=None, InstanceCount=None, PriceSchedules=None, ClientToken=None):\n pass",
"async def set_charge_schedule... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Requests a reboot of one or more instances. This operation is asynchronous; it only queues a request to reboot the specified instances. The operation succeeds if the instances are valid and belong to you. Requests to reboot terminated instances are ignored. If an instance does not cleanly shut down within four minutes,... | def reboot_instances(DryRun=None, InstanceIds=None):
pass | [
"def rebootInstances(self, api_client):\n\n cmd = {'group': self.id}\n return api_client.rebootVirtualMachine(**cmd)",
"def restart() -> None:\n config = load_config_file()\n instance_ips = [i.public_ip_address for i in get_running_instances(config)]\n if not instance_ips:\n raise Ex... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Registers an AMI. When you're creating an AMI, this is the final step you must complete before you can launch an instance from the AMI. For more information about creating AMIs, see Creating Your Own AMIs in the Amazon Elastic Compute Cloud User Guide . You can also use RegisterImage to create an Amazon EBSbacked Linux... | def register_image(DryRun=None, ImageLocation=None, Name=None, Description=None, Architecture=None, KernelId=None, RamdiskId=None, BillingProducts=None, RootDeviceName=None, BlockDeviceMappings=None, VirtualizationType=None, SriovNetSupport=None, EnaSupport=None):
pass | [
"def create_ami(self,instance_id,instance_name):\n #instance_name = conn.get_instance_attribute(instance_id, 'name')\n\n root_device = '/dev/sda1'\n\n block_map = self.block_device_map_for_instance(instance_id) # all the action starts here\n #description for daily\n if options.dai... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Rejects a VPC peering connection request. The VPC peering connection must be in the pendingacceptance state. Use the DescribeVpcPeeringConnections request to view your outstanding VPC peering connection requests. To delete an active VPC peering connection, or to delete a VPC peering connection request that you initiate... | def reject_vpc_peering_connection(DryRun=None, VpcPeeringConnectionId=None):
pass | [
"def reject_private_endpoint_connection(client, resource_group_name, account_name, private_endpoint_connection_name,\n description=None):\n\n return _update_private_endpoint_connection_status(\n client, resource_group_name, account_name, private_endpoint_connection_na... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
When you no longer want to use an OnDemand Dedicated Host it can be released. OnDemand billing is stopped and the host goes into released state. The host ID of Dedicated Hosts that have been released can no longer be specified in another request, e.g., ModifyHosts. You must stop or terminate all instances on a host bef... | def release_hosts(HostIds=None):
pass | [
"def deactivate_host_if_up(host, host_resource=None):\n if not ll_hosts.is_host_in_maintenance(positive=True, host=host):\n return ll_hosts.deactivate_host(\n positive=True, host=host, host_resource=host_resource\n )\n return True",
"def cleanup_hosts(context):\n host1_name = con... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Replaces an IAM instance profile for the specified running instance. You can use this action to change the IAM instance profile that's associated with an instance without having to disassociate the existing IAM instance profile first. Use DescribeIamInstanceProfileAssociations to get the association ID. | def replace_iam_instance_profile_association(IamInstanceProfile=None, AssociationId=None):
pass | [
"def update_policy_profile(self, profile, body=None):\n return self._put(self.policy_profile_path % (profile), body=body)",
"def delete_profile(self):\n response = self.client.delete_instance_profile(\n InstanceProfileName=self.ProfileName\n )",
"def update(self, profile_id, profile,... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Replaces an entry (rule) in a network ACL. For more information about network ACLs, see Network ACLs in the Amazon Virtual Private Cloud User Guide . | def replace_network_acl_entry(DryRun=None, NetworkAclId=None, RuleNumber=None, Protocol=None, RuleAction=None, Egress=None, CidrBlock=None, Ipv6CidrBlock=None, IcmpTypeCode=None, PortRange=None):
pass | [
"def replace_network_acl_entry(\n network_acl_id=None,\n rule_number=None,\n protocol=None,\n rule_action=None,\n cidr_block=None,\n egress=None,\n network_acl_name=None,\n icmp_code=None,\n icmp_type=None,\n port_range_from=None,\n port_range_to=None,\n region=None,\n key=Non... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Submits feedback about the status of an instance. The instance must be in the running state. If your experience with the instance differs from the instance status returned by DescribeInstanceStatus , use ReportInstanceStatus to report your experience with the instance. Amazon EC2 collects this information to improve th... | def report_instance_status(DryRun=None, Instances=None, Status=None, StartTime=None, EndTime=None, ReasonCodes=None, Description=None):
pass | [
"def _UpdateInstanceStatus(filename, instances):\n _WriteInstanceStatus(filename, [(inst.name, inst.status)\n for inst in instances])",
"def _wait_for_instance_running_state(self):\n\n assert self._instance\n\n tries = 0\n start_time = time.time()\n wh... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Creates a Spot fleet request. You can submit a single request that includes multiple launch specifications that vary by instance type, AMI, Availability Zone, or subnet. By default, the Spot fleet requests Spot instances in the Spot pool where the price per unit is the lowest. Each launch specification can include its ... | def request_spot_fleet(DryRun=None, SpotFleetRequestConfig=None):
pass | [
"def create_fleet(Name=None, Description=None, BuildId=None, ServerLaunchPath=None, ServerLaunchParameters=None, LogPaths=None, EC2InstanceType=None, EC2InboundPermissions=None, NewGameSessionProtectionPolicy=None, RuntimeConfiguration=None, ResourceCreationLimitPolicy=None, MetricGroups=None):\n pass",
"def m... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Creates a Spot instance request. Spot instances are instances that Amazon EC2 launches when the bid price that you specify exceeds the current Spot price. Amazon EC2 periodically sets the Spot price based on available Spot Instance capacity and current Spot instance requests. For more information, see Spot Instance Req... | def request_spot_instances(DryRun=None, SpotPrice=None, ClientToken=None, InstanceCount=None, Type=None, ValidFrom=None, ValidUntil=None, LaunchGroup=None, AvailabilityZoneGroup=None, BlockDurationMinutes=None, LaunchSpecification=None):
pass | [
"def create_spot_instance(config, job_id, sched_time, docker_image, env_vars):\n\n client = boto3.client('ec2')\n\n # Get my own public fqdn by quering metadata\n my_own_name = urllib2.urlopen(\n \"http://169.254.169.254/latest/meta-data/public-hostname\").read()\n\n user_data = (\n \"#!/b... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Resets an attribute of an AMI to its default value. | def reset_image_attribute(DryRun=None, ImageId=None, Attribute=None):
pass | [
"def reset_instance_attribute(DryRun=None, InstanceId=None, Attribute=None):\n pass",
"def default_attribute(self, default_attribute):\n\n self._default_attribute = default_attribute",
"def reset(self):\n self._value = self._default_value",
"def _restore_attribute(\n cls, obj: CommonTy... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Resets an attribute of an instance to its default value. To reset the kernel or ramdisk , the instance must be in a stopped state. To reset the sourceDestCheck , the instance can be either running or stopped. The sourceDestCheck attribute controls whether source/destination checking is enabled. The default value is tru... | def reset_instance_attribute(DryRun=None, InstanceId=None, Attribute=None):
pass | [
"def modify_instance_attribute(DryRun=None, InstanceId=None, Attribute=None, Value=None, BlockDeviceMappings=None, SourceDestCheck=None, DisableApiTermination=None, InstanceType=None, Kernel=None, Ramdisk=None, UserData=None, InstanceInitiatedShutdownBehavior=None, Groups=None, EbsOptimized=None, SriovNetSupport=No... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Resets a network interface attribute. You can specify only one attribute at a time. | def reset_network_interface_attribute(DryRun=None, NetworkInterfaceId=None, SourceDestCheck=None):
pass | [
"def _restore_attribute(\n cls, obj: CommonTypes.MLRunInterfaceableType, attribute_name: str\n ):\n # Get the original attribute:\n original_attribute_name = cls._ORIGINAL_ATTRIBUTE_NAME.format(attribute_name)\n original_attribute = getattr(obj, original_attribute_name)\n\n # S... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Restores an Elastic IP address that was previously moved to the EC2VPC platform back to the EC2Classic platform. You cannot move an Elastic IP address that was originally allocated for use in EC2VPC. The Elastic IP address must not be associated with an instance or network interface. | def restore_address_to_classic(DryRun=None, PublicIp=None):
pass | [
"def ex_release_public_ip(self, address):\r\n return self.driver.ex_release_public_ip(self, address)",
"def disassociate_address(DryRun=None, PublicIp=None, AssociationId=None):\n pass",
"def _assign_secondary_ip_():\n interface_idx = 0\n node = env.nodes[0]\n cidr='%s/%s' % (env.secondary_ip... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
[EC2VPC only] Removes one or more egress rules from a security group for EC2VPC. This action doesn't apply to security groups for use in EC2Classic. The values that you specify in the revoke request (for example, ports) must match the existing rule's values for the rule to be revoked. Each rule consists of the protocol... | def revoke_security_group_egress(DryRun=None, GroupId=None, SourceSecurityGroupName=None, SourceSecurityGroupOwnerId=None, IpProtocol=None, FromPort=None, ToPort=None, CidrIp=None, IpPermissions=None):
pass | [
"def revoke_security_group_ingress(DryRun=None, GroupName=None, GroupId=None, SourceSecurityGroupName=None, SourceSecurityGroupOwnerId=None, IpProtocol=None, FromPort=None, ToPort=None, CidrIp=None, IpPermissions=None):\n pass",
"def delete_security_groups():\n print('Deleting Security Groups')\n client ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Removes one or more ingress rules from a security group. The values that you specify in the revoke request (for example, ports) must match the existing rule's values for the rule to be removed. Each rule consists of the protocol and the CIDR range or source security group. For the TCP and UDP protocols, you must also s... | def revoke_security_group_ingress(DryRun=None, GroupName=None, GroupId=None, SourceSecurityGroupName=None, SourceSecurityGroupOwnerId=None, IpProtocol=None, FromPort=None, ToPort=None, CidrIp=None, IpPermissions=None):
pass | [
"def revoke_security_group_egress(DryRun=None, GroupId=None, SourceSecurityGroupName=None, SourceSecurityGroupOwnerId=None, IpProtocol=None, FromPort=None, ToPort=None, CidrIp=None, IpPermissions=None):\n pass",
"def remove_securitygroup_rules(self, group_id, rules):\n return self.security_group.removeR... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Launches the specified Scheduled Instances. Before you can launch a Scheduled Instance, you must purchase it and obtain an identifier using PurchaseScheduledInstances . You must launch a Scheduled Instance during its scheduled time period. You can't stop or reboot a Scheduled Instance, but you can terminate it as neede... | def run_scheduled_instances(DryRun=None, ClientToken=None, InstanceCount=None, ScheduledInstanceId=None, LaunchSpecification=None):
pass | [
"def run_instances(self):\n # create an entry in the s3 log for the start of this task \n self.log_to_s3('run-instances-start.log', 'start')\n\n session = botocore.session.get_session()\n client = session.create_client('ec2', region_name=self.aws_region)\n\n # convert user-data to... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Unassigns one or more IPv6 addresses from a network interface. | def unassign_ipv6_addresses(NetworkInterfaceId=None, Ipv6Addresses=None):
pass | [
"def UnassignIpv6Addresses(self, request):\n try:\n params = request._serialize()\n headers = request.headers\n body = self.call(\"UnassignIpv6Addresses\", params, headers=headers)\n response = json.loads(body)\n model = models.UnassignIpv6AddressesRespo... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Unassigns one or more secondary private IP addresses from a network interface. | def unassign_private_ip_addresses(NetworkInterfaceId=None, PrivateIpAddresses=None):
pass | [
"def unassign_ipv6_addresses(NetworkInterfaceId=None, Ipv6Addresses=None):\n pass",
"def assign_private_ip_addresses(NetworkInterfaceId=None, PrivateIpAddresses=None, SecondaryPrivateIpAddressCount=None, AllowReassignment=None):\n pass",
"def do_del_private_ip(vnic_utils, delete_options):\n # needs the... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Disables detailed monitoring for a running instance. For more information, see Monitoring Your Instances and Volumes in the Amazon Elastic Compute Cloud User Guide . | def unmonitor_instances(DryRun=None, InstanceIds=None):
pass | [
"def disable_performance_metrics(self) -> bool:\n return pulumi.get(self, \"disable_performance_metrics\")",
"def enable_instance_inspection(request):\n log('Enabling instance inspection')\n _assign_role(request, _get_role('vm-reader'))",
"def disable(self):\n hoomd.util.print_status_line()\... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Thread safe print function | def multithread_safe(self, *args, **kwargs) -> None:
with self.s_print_lock:
print(*args, **kwargs) | [
"def my_print(msg):\r\n with print_lock:\r\n print(msg)",
"def write():\n with LOCK:\n sys.stdout.write(\"%s writing..\" % threading.current_thread().name)\n time.sleep(random.random())\n sys.stdout.write(\"..done\\n\")",
"def _print(data):\n sys.stdout.buffer.write(data)",
... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Pretty print of list, dicts, tuples `param object_` object to print `param indent` indent to new nested level `param quiet` suppress print to console `return` from pprint.pformat | def prettify(self, object_: Union[list, dict, tuple], indent: int = 4, quiet: bool = False) -> str:
import pprint
pretty_printer = pprint.PrettyPrinter(indent=indent)
pretty_string = pretty_printer.pformat(object=object_)
if not quiet:
self.multithread_safe(pretty_string)
... | [
"def pp(object):\n return pprint.PrettyPrinter(indent=2, width=200).pprint(object)",
"def pprint(obj):\n print(json.dumps(obj, sort_keys=True, indent=4, separators=(',', ': ')))",
"def dprint(object, stream=None, indent=1, width=80, depth=None):\n # Catch any singleton Django model object that might ge... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Returns None for unparseable term names. | def test_unparseable_term_name(self):
assert berkeley.sis_term_id_for_name('Winter 2061') is None
assert berkeley.sis_term_id_for_name('Default Term') is None | [
"def test_missing_term_name(self):\n assert berkeley.sis_term_id_for_name(None) is None",
"def single_term(self):\n if self.terms.keys() == ['text'] and len(self.terms['text']) == 1:\n return self.terms['text'][0]['arg']",
"def try_parse_name(line):\n match = re.search(NAME_PATTERN, ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Returns None for missing term names. | def test_missing_term_name(self):
assert berkeley.sis_term_id_for_name(None) is None | [
"def test_unparseable_term_name(self):\n assert berkeley.sis_term_id_for_name('Winter 2061') is None\n assert berkeley.sis_term_id_for_name('Default Term') is None",
"def single_term(self):\n if self.terms.keys() == ['text'] and len(self.terms['text']) == 1:\n return self.terms['te... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
We must have unique dept codes and unique names. | def test_unique_department_names(self):
assert len(BERKELEY_DEPT_CODE_TO_NAME) == len(BERKELEY_DEPT_NAME_TO_CODE) | [
"def test_get_unique_fields(self):\n from nomnom.tests.models import Department\n self.assertListEqual(['id','code'], get_unique_field_names(Department))",
"def test_create_department_invalid_values_fails(self, client, dept_data):\n data = dept_data['test_dept']\n data.update({'name': ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Checks that force flag overwrites page if the author is different | def test_post_force_overwrite_other_author(force_flag, tmp_path, setup_page):
config_file, (page_id, page_title) = setup_page(1)
original_username = Config(config_file).author
new_config = replace_new_author(config_file=config_file, tmp_path=tmp_path)
new_text = rewrite_page_file(Config(new_config).page... | [
"def test_bad_author(self):\n author_links = []\n page_url = \"hola\"\n author_links.append(page_url)\n self.assertEqual(author_scraper.scrape_author(author_links), False)",
"def test_func(self):\n article = self.get_object()\n if self.request.user == article.author:\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Creates a page and tries to overwrite it as the same user. Checks that the force_flag does not matter | def test_create_and_overwrite_page(force_flag, setup_page):
config_file, (page_id, page_title) = setup_page(1)
new_text = rewrite_page_file(Config(config_file).pages[0].page_file)
overwrite_result = run_with_config(
config_file=config_file,
pre_args=["--force"] * force_flag,
)
asser... | [
"def test_post_force_overwrite_other_author(force_flag, tmp_path, setup_page):\n config_file, (page_id, page_title) = setup_page(1)\n original_username = Config(config_file).author\n new_config = replace_new_author(config_file=config_file, tmp_path=tmp_path)\n new_text = rewrite_page_file(Config(new_con... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Copy a dinosaur. This returns a new alive dinosaur with score 0. It only copies DNA and behavior | def from_dinosaur(dinosaur):
newdino = AIDinosaur(dinosaur.surfaceheight)
newdino.dna = dinosaur.dna.copy()
newdino.score = 0
newdino.behavior = AIDinoBehavior(newdino.dna)
return newdino | [
"def copy(toCopy):\r\n copiedPkmn = copy.deepcopy(toCopy)\r\n copiedPkmn.battleDelegate.attacks = toCopy.battleDelegate.attacks\r\n return copiedPkmn",
"def copy(self, new_id=None):\n if not new_id:\n copy = ScriptedSprite(self.id+'_copy', self.rect.topleft, self.rect.size, ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
QCoreApplication.notify(QObject, QEvent) > bool | def notify(self, QObject, QEvent): # real signature unknown; restored from __doc__
return False | [
"def sendEvent(self, QObject, QEvent): # real signature unknown; restored from __doc__\r\n return False",
"def sendEvent(self, QGraphicsItem, QEvent): # real signature unknown; restored from __doc__\r\n return False",
"def notify(self, observed, arg_bundle = None):\n\t\tpass",
"def monitor_cb(ud... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
QCoreApplication.postEvent(QObject, QEvent) QCoreApplication.postEvent(QObject, QEvent, int) | def postEvent(self, QObject, QEvent, p_int=None): # real signature unknown; restored from __doc__ with multiple overloads
pass | [
"def sendEvent(self, QObject, QEvent): # real signature unknown; restored from __doc__\r\n return False",
"def sendEvent(self, QGraphicsItem, QEvent): # real signature unknown; restored from __doc__\r\n return False",
"def test_qeventloop_exec(qtbot):\n assert QtCore.QEventLoop.exec_ is not Non... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
QCoreApplication.sendEvent(QObject, QEvent) > bool | def sendEvent(self, QObject, QEvent): # real signature unknown; restored from __doc__
return False | [
"def sendEvent(self, QGraphicsItem, QEvent): # real signature unknown; restored from __doc__\r\n return False",
"def can_handle(cls, event: dict) -> bool:",
"def check_event(self, event):\n # pylint: disable=R0201, W0613\n return True",
"def test_qeventloop_exec(qtbot):\n assert QtCore... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
QCoreApplication.translate(str, str, str disambiguation=None, QCoreApplication.Encoding encoding=QCoreApplication.CodecForTr) > QString QCoreApplication.translate(str, str, str, QCoreApplication.Encoding, int) > QString | def translate(p_str, p_str_1, *__args): # real signature unknown; restored from __doc__ with multiple overloads
return QString | [
"def translate(input_str, lang_source, lang_target):\n pass",
"def translation(text):\n\tinput_text = TextBlob(text)\n\tclick.secho(\"Text Translation\",fg='black',bg='white')\n\tclick.secho(\"Original Text: {}\".format(text),fg='yellow')\n\tclick.secho(\"Translated Text {}\".format(input_text.translate(to='en... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |