query stringlengths 9 9.05k | document stringlengths 10 222k | negatives listlengths 19 20 | metadata dict |
|---|---|---|---|
Determines if a line is horizontal. | def is_horizontal(line:tuple)->bool:
return line[0][1] == line[1][1] | [
"def is_horizontal(self):\n return self.start.x == self.end.x",
"def _isLine(self):\n return (self.width == 0 and self.height > 1) or (self.height == 0 and self.width > 1)",
"def check_horizontal_rule(line):\n if line.count('-') >= 3 and contains_only_char(line, '-'):\n return True, '<hr... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Determines the length and the cosine of the angle from a positive horizontal ray of a line segment. | def line_length_angle(line:tuple)->tuple:
squared_dist = point_sqr_distance(line[0], line[1])
if squared_dist == 0:
return 0,1
distance = math.sqrt(squared_dist)
angle_cosine = (line[1][0] - line[0][0]) / distance
return squared_dist, angle_cosine | [
"def determine_angle_slope(line, ax):\n x, y = line.get_data()\n\n sp1 = ax.transData.transform_point((x[0],y[0]))\n sp2 = ax.transData.transform_point((x[-1],y[-1]))\n\n rise = (sp2[1] - sp1[1])\n run = (sp2[0] - sp1[0])\n\n return degrees(atan(rise/run))",
"def calc_line(line):\n\n if line[... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Takes a sequential list of vertices and turns it into a list of edges. | def edgify(vertices:list)->list:
edges = []
for k in range(0, len(vertices) - 1):
edges.append([vertices[k], vertices[k + 1]])
return edges | [
"def to_edges(graph):\n return list(zip(graph[:-1], graph[1:]))",
"def create_edges_list(consistency_matrix, vertices_list):\r\n edge_list = []\r\n for i, weights in enumerate(consistency_matrix):\r\n for x, weight in enumerate(weights):\r\n if weight != float('inf'):\r\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Determines the closest point on the infinite line associated with the edge to the given point. The closest point on an infinite line to a point is determined by the intersection of that line (y=mx+b) and a perpendicular line through the | def closest_line_point(point:tuple, edge:tuple)->tuple:
d_y, d_x, b = line_equation((edge[0], edge[1]))
if b == None:
# The line is vertical, need different intercept formula.
return (edge[0][0], point[1])
if d_y == 0:
# The line is horizontal, we can use a faster formula:
re... | [
"def _nearest_point_on_line(begin, end, point):\n b2e = _vec_sub(end, begin)\n b2p = _vec_sub(point, begin)\n nom = _vec_dot(b2p, b2e)\n denom = _vec_dot(b2e, b2e)\n if denom == 0.0:\n return begin\n u = nom / denom\n if u <= 0.0:\n return begin\n elif u >= 1.0:\n return... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Checks if a value is between two boundary values | def between(check:float, boundary_1:float, boundary_2:float)->bool:
if boundary_1 > boundary_2:
boundary_1, boundary_2 = boundary_2, boundary_1
return boundary_1 <= check and check <= boundary_2 | [
"def _between(self, value: Any) -> bool:\n return float(self.op[0]) <= value <= float(self.op[1])",
"def is_between(low, x, high):\n return (low <= x) and (x <= high)",
"def test_if_between(a, b, test_val):\n if a < b:\n return a <= test_val <= b\n else:\n return b <= test_val <= a... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Checks if a point is within the rectangle with edge as one of the diagonals. | def near_segment(point:tuple, edge:tuple)->bool:
return between(point[0], edge[0][0], edge[1][0]) and between(point[1], edge[0][1], edge[1][1]) | [
"def inside(point, rectangle):\n\n\tul = rectangle.getP1() # assume p1 is upper left\n\tlr = rectangle.getP2() # assume p2 is lower right \n\n\treturn ul.getX() < point.getX() < lr.getX() and ul.getY() < point.getY() < lr.getY()",
"def inside(point, rectangle):\n\n ll = rectangle.getP1() # assume p1 is ll (lo... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Returns true if the vector is a zero vector, otherwise false. | def is_zero_vector(vector:tuple)->bool:
return vector[0] == 0 and vector[1] == 0 | [
"def isZeroVector(vector):\n if vector.x == 0 and vector.y == 0 and vector.z == 0:\n return True\n return False",
"def zero_vector_p(vector):\n return False if np.count_nonzero(vector) else True",
"def is_zero(self):\n for t in self:\n if t != TRIT_ZERO:\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Creates a convex line segment between two points. In the context of polygon creation, desc_y is set to True if we are building the top left or top right corner. Desc_X is set to True if we are building the top right or bottom right corner. This impacts the order we accept points and how we interpret the direction of po... | def convex_line_segment(point_list:list, desc_y:bool=False, desc_x:bool=False)->list:
if len(point_list) < 3:
return point_list
line = []
x_extrema = None
# Since the list is sorted by x second, the last point is actually the
# first point of the last block of y values in the list (if more t... | [
"def _create_new_segments(self,line1,line2):\n\n bisector = self._angle_bisection(line1,line2)\n new_points = self._projections(line1,line2,bisector)\n \n new_segments = []\n\n if len(new_points) == 2 and ((np.allclose(new_points[0][0],new_points[1][1]) and np.allclose(new_points[... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Determines if a line segment described by d_y, d_x, and b is right of a point. | def intersects_right(point:tuple, line:tuple, d_y:float, d_x:float, b:float, include_top:bool=False, inclusive:bool=False)->bool:
min_y, max_y = line[0][1], line[1][1]
if min_y > max_y:
min_y, max_y = max_y, min_y
if not between(point[1], min_y, max_y):
# The point is above or below the line... | [
"def is_point_right_of_line(a: LineSegment, b: Point) -> bool:\n # Move the image, so that a.p1 is on (0|0)\n a_tmp = LineSegment(Point(0, 0), Point(a.p2.x - a.p1.x, a.p2.y - a.p1.y))\n b_tmp = Point(b.x - a.p1.x, b.y - a.p1.y)\n return crossproduct(a_tmp.p2, b_tmp) < 0",
"def is_point_on_line(a: Line... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Determines the crossing number of a horizontal positive ray from point with a polygon defined in edges. | def crossing_number(point:tuple, edges:list, include_edges:bool=True)->int:
crossing_number = 0
for edge in edges:
d_y, d_x, b = line_equation(edge)
if include_edges and point_on_line(point, edge, d_y, d_x, b):
return 1
if is_horizontal(edge):
continue
if ... | [
"def winding_number(x, y, primitive):\n\n wn = 0\n\n edges = zip(primitive[\"vertices\"][-1:] + primitive[\"vertices\"][:-1],\n primitive[\"vertices\"])\n for edge in edges:\n # check if cuts y parallel line at (x, y) &&\n if (edge[0][0] > x) != (edge[1][0] > x):\n #... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Select the longest edge from hull that doesn't start with a point in ignore_left_points, with minimum length. Returns | def select_longest_edge(hull:list, ignore_left_points:list, min_sqr_length:int=0)->tuple:
max_sqr_length = None
selected = None
for k in range(0, len(hull) - 1):
if hull[k] in ignore_left_points:
continue
edge_sqr_length = point_sqr_distance(hull[k], hull[k+1])
if edge_sq... | [
"def indices_on_lower_right_hull_from_left(x, y):\n def check(array, name):\n if not np.issubdtype(array.dtype, np.floating):\n raise ValueError(\"%s needs to be of float type.\" % name)\n if len(array.shape) != 1:\n raise ValueError(\"%s needs to be a vector.\" % name)\n check(x, \"x\")\n check(... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Determines if the new edge would intersect the hull at any point. | def segments_intersects_hull(new_edges:list, hull:list, current_edge:tuple)->bool:
new_edge_extent = extent(new_edges[0][0], new_edges[0][1], new_edges[1][1])
for k in range(0, len(hull) - 1):
if new_edges[0][0] == hull[k] or new_edges[0][0] == hull[k+1]:
continue
elif new_edges[0][1... | [
"def is_new(self):\n c_up = self.upper_binary_tree().single_edge_cut_shapes()\n c_down = self.lower_binary_tree().single_edge_cut_shapes()\n return not any(x in c_up for x in c_down)",
"def in_convex_hull(p, hull):\n from scipy.spatial import Delaunay\n if not isinstance(hull,Delaunay):... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Creates a concave hull. | def concave_hull(hull:list, points:list, max_iterations:int=None, min_length_fraction:float=0, min_angle:float=90)->list:
tweet.info("Creating concave hull; minimum side length {}% of average, minimum_angle {}".format(min_length_fraction * 100, min_angle))
test_points = set(points)
ignore_points = []
av... | [
"def convex_hull(self):",
"def _convex_hull(points):\n\n # Sort the points lexicographically (tuples are compared lexicographically).\n # Remove duplicates to detect the case we have just one unique point.\n points = sorted(set(points))\n\n # Boring case: no points or a single point, possibly repeated... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Provides the next sample to take. After this method is called, the self.inputInfo should be ready to be sent to the model @ In, model, model instance, an instance of a model @ In, myInput, list, a list of the original needed inputs for the model (e.g. list of files, etc.) @ Out, None | def localGenerateInput(self, model, myInput):
if self.counter < 2:
MCMC.localGenerateInput(self, model, myInput)
else:
self._localReady = False
for key, value in self._updateValues.items():
# update value based on proposal distribution
newVal = value + self._proposal[key].rvs()... | [
"def input(self):\n try:\n return self.inputs[-1]\n except IndexError:\n pass\n raise ValueError(\"The sample method has not been called\")",
"def process_input():\n author = sys.argv[1]\n steps = 5000\n print len(sys.argv)\n if len(sys.argv) > 2:\n st... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
General function (available to all samplers) that finalize the sampling calculation just ended. In this case, The function is aimed to check if all the batch calculations have been performed @ In, jobObject, instance, an instance of a JobHandler @ In, model, model instance, it is the instance of a RAVEN model @ In, myI... | def localFinalizeActualSampling(self, jobObject, model, myInput):
MCMC.localFinalizeActualSampling(self, jobObject, model, myInput) | [
"def localFinalizeActualSampling(self, jobObject, model, myInput):\n # check if all sampling is done\n if self.jobHandler.isFinished():\n self.batchDone = True\n else:\n self.batchDone = False\n # batchDone is used to check if the sampler should find new points.",
"def localFinalizeActualSam... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Used to feedback the collected runs within the sampler @ In, newRlz, dict, new generated realization @ In, currentRlz, dict, the current existing realization @ Out, netLogPosterior, float, the accepted probabilty | def _useRealization(self, newRlz, currentRlz):
netLogPosterior = 0
# compute net log prior
for var in self._updateValues:
newVal = newRlz[var]
currVal = currentRlz[var]
if var in self.distDict:
dist = self.distDict[var]
netLogPrior = dist.logPdf(newVal) - dist.logPdf(currVa... | [
"def learn(self):\r\n \r\n # take a mini-batch from replay experience\r\n cur_batch_size = min(len(self.replay_exp), self.batch_size)\r\n mini_batch = random.sample(self.replay_exp, cur_batch_size)\r\n \r\n # batch data\r\n sample_states = np.ndarray(shape = (cur_bat... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Gets the applicable_job_statuses of this Lifecycle. Job status needs to be in this list in order for the action to be performed! | def applicable_job_statuses(self):
return self._applicable_job_statuses | [
"def statuses(self) -> List[Union[JobStatus, None]]:\n return [mjob.status() for mjob in self._managed_jobs]",
"def applicable_job_statuses(self, applicable_job_statuses):\n allowed_values = []\n if applicable_job_statuses not in allowed_values:\n raise ValueError(\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Sets the applicable_job_statuses of this Lifecycle. Job status needs to be in this list in order for the action to be performed! | def applicable_job_statuses(self, applicable_job_statuses):
allowed_values = []
if applicable_job_statuses not in allowed_values:
raise ValueError(
"Invalid value for `applicable_job_statuses` ({0}), must be one of {1}"
.format(applicable_job_statuses, allowed... | [
"def applicable_job_statuses(self):\n return self._applicable_job_statuses",
"def set_status(self, status):\n if status not in STATUSES:\n raise ValueError(\"status %r unknown (should be one of %r)\" %\n (status, STATUSES))\n if status == STATUS_DONE:\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Gets the action_time of this Lifecycle. The time at which the job and files will be deleted, regardless of whether it has been retrieved or not. Maximal time is 1 day from job creation | def action_time(self):
return self._action_time | [
"def get_delete_time(self):\n return self._dtime",
"def revert_action_start_time(self) -> str:\n return pulumi.get(self, \"revert_action_start_time\")",
"def time_consumed(self) -> int:\n if not self.actions:\n return 0\n else:\n return self.actions[-1].time_end... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Sets the action_time of this Lifecycle. The time at which the job and files will be deleted, regardless of whether it has been retrieved or not. Maximal time is 1 day from job creation | def action_time(self, action_time):
self._action_time = action_time | [
"def last_action_date_time(self, last_action_date_time):\n\n self._last_action_date_time = last_action_date_time",
"def action_time(self):\n return self._action_time",
"def on_action_time_changed(self, content):\n time = parse_iso_dt(content['time']).time()\n self.set_guarded(time=ti... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Sets the action of this Lifecycle. The action to perform. Currently only delete is supported | def action(self, action):
allowed_values = ["DELETE", "NONE"]
if action not in allowed_values:
raise ValueError(
"Invalid value for `action` ({0}), must be one of {1}"
.format(action, allowed_values)
)
self._action = action | [
"def set_action(self, action):\n self.action = action",
"def action(self, action: str):\n\n self._action = action",
"def _set_action(self, v, load=False):\n try:\n t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_type=\"dict_key... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Sets the type of this Lifecycle. Determine when to delete the job and associated files. RETRIEVAL means delete directly after retrieving the PDF file. When the file has not been retrieved before the action time, it will be deleted regardless. Time means, delete on specific time, regardless of whether it has been proces... | def type(self, type):
allowed_values = ["RETRIEVAL", "TIME"]
if type not in allowed_values:
raise ValueError(
"Invalid value for `type` ({0}), must be one of {1}"
.format(type, allowed_values)
)
self._type = type | [
"def __init__(__self__, *,\n duration: pulumi.Input[str],\n object_type: pulumi.Input[str]):\n pulumi.set(__self__, \"duration\", duration)\n pulumi.set(__self__, \"object_type\", 'AbsoluteDeleteOption')",
"def ExpireType(self):\n if self.force_auto_sync:\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Basic test for findService parsing with a civic address. | def test_findservice_civic_address(self):
xml = """
<findService xmlns="urn:ietf:params:xml:ns:lost1" serviceBoundary="reference">
<location id="ce152f4b-2ade-4e37-9741-b6649e2d87a6" profile="civic">
<civ:civicAddress xmlns:civ="urn:ietf:params:xml:ns:pidf:geopri... | [
"def test_retrieve_address(self):\n pass",
"def test_search_address_type(self):\n pass",
"def test_client_address_retrieve(self):\n pass",
"def test_search_entry_address(self):\n pass",
"def test_ipam_services_read(self):\n pass",
"def test_get_service_string(self):\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Returns the dialogueIDth caption from vttFile | def getCaptionFromVTTcaptionFile(vttFile, dialogueID):
import webvtt
return webvtt.read(vttFile)[dialogueID].text | [
"def get_caption(self):\n return self._caption",
"def caption(self):\n return self.__caption",
"def __load_dialogue_ids(self, filename):\n with open(filename, \"r\") as file:\n return file.readlines()[0].split()",
"def caption(nasa_id):\n location = _get_caption_location(nas... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Perform comparison $ python compareAudio.py audioFile(.webm), netflixWatchID(str), dialogueID(number), gameID(str) | def performThreeComparisons(netflixWatchID, dialogueID, audioFile, gameID, userTranscript, emoPredictor, verbose=False, profile=False, logErrors=True):
logFile = "logFile.txt"
errorsLst = []
resultDICT = {"gameID" : gameID, "dialogueID" : dialogueID, "error" : "", "success" : True}
overallscore = 0.0
... | [
"def check_file_audio(self, file_id):\n c = self.connection.cursor()\n c.execute('SELECT telegramid FROM FileAudios WHERE id=?', (file_id,))\n result = c.fetchone()\n if result is not None:\n return result[0]",
"def testfiles():\n\timport pyechonest.track\n\tfor file in get_... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Init constructor of HID. | def __init__(self, vendor_id: int = 0x2C97, hid_path: Optional[bytes] = None) -> None:
if hid is None:
raise ImportError("hidapi is not installed, try: "
"'pip install ledgercomm[hid]'")
self.device = hid.device()
self.path: Optional[bytes] = hid_path
... | [
"def __init__(self, vid, pid):\n self.hid = hidDevice(vid, pid, callback = self.callback)\n self.waitdata = False",
"def __init__(self, port_id, usb_ctrl):\n BluetoothHIDFlow.__init__(self, port_id, 'BleMouse', usb_ctrl,\n nRF52.USB_VID, nRF52.USB_PID)\n BluetoothH... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Open connection to the HID device. Returns None | def open(self) -> None:
if not self.__opened:
if self.path is None:
self.path = HID.enumerate_devices(self.vendor_id)[0]
self.device.open_path(self.path)
self.device.set_nonblocking(True)
self.__opened = True | [
"def open_connection(self):\n if self.no_install:\n logging.warn('Running with no_install option - copy files only...')\n try:\n logging.warn('Connecting to ' + self.host + '...')\n self.dev = Device(host=self.host,\n user=self.auth['userna... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Receive data through HID device `self.device`. Blocking IO. Returns Tuple[int, bytes] A pair (sw, rdata) containing the status word and response data. | def recv(self) -> Tuple[int, bytes]:
seq_idx: int = 0
self.device.set_nonblocking(False)
data_chunk: bytes = bytes(self.device.read(64 + 1))
self.device.set_nonblocking(True)
assert data_chunk[:2] == b"\x01\x01"
assert data_chunk[2] == 5
assert data_chunk[3:5] ==... | [
"def receive_data( self ):\n #--------------------------------------------------------------------------\n \n try:\n msgtype = self.sd.read( 4 )\n if not msgtype: \n return (None, None)\n \n lenstr = self.sd.read( 4 )\n msglen = int(... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Search through the provided list of devices to find the one with the matching usage_page and usage. | def find_device(devices, *, usage_page, usage):
if hasattr(devices, "send_report"):
devices = [devices]
for device in devices:
if (
device.usage_page == usage_page
and device.usage == usage
and hasattr(device, "send_report")
):
return devic... | [
"def search_devices(NextToken=None, MaxResults=None, Filters=None, SortCriteria=None):\n pass",
"def ListDevices(self, request):\n logging.debug(\"ClusterDeviceApi.NDBListDevices request: %s\", request)\n if (request.elastic_query is not None and\n env_config.CONFIG.use_elasticsearch): # pytype: ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
function to convert contribs collection items to edges ones edge doc {_id, name_1, name_2, tags [{name, urls[]}]} =========================================================== if src in srcs then skip if name_1 and name_2 not found then insert new doc if tag.name not found then insert new tag if tag.url not found then in... | def contribs2edges():
client = mongo.MongoClient(config["MONGO_URI"])
db = client.links
db.edges.remove()
edges = dict()
for contrib in db.contribs.find():
for item in contrib["data"]:
id = u"{} {}".format(item["name_1"], item["name_2"]).replace(" ", "_")
edge... | [
"def add_all_to_document(nml_doc_src, nml_doc_tgt, verbose=False):\n membs = inspect.getmembers(nml_doc_src)\n\n for memb in membs:\n if isinstance(memb[1], list) and len(memb[1]) > 0 and not memb[0].endswith(\"_\"):\n for entry in memb[1]:\n if memb[0] != \"includes\":\n\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
VStream streams vreplication events. | def VStream(self, request, context):
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
context.set_details('Method not implemented!')
raise NotImplementedError('Method not implemented!') | [
"def stream_status_event(self, event):\r\n pass",
"def broadcast_logs(self):\n self._log_storage.serve_streams()",
"def event_stream(self):\n for message in self.subscribe():\n event = message_to_sse(message[\"data\"])\n yield event",
"def initialize_vrep_streaming_opera... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Removes rows which aren't needed in the DF. If a row contains one of the designated symbols it drops them and records them. Returns an Filtered object which contains information about the retained and removed rows. | def filter_unneeded_rows(data: pd.DataFrame) -> FilteredData:
allowed_values = ["BUY", "SELL"]
correct_rows = data["Action"].isin(allowed_values)
num_of_ok_rows = correct_rows.sum()
if num_of_ok_rows == len(data):
return FilteredData(data, {})
legal_rows = data.loc[correct_rows, :]
illeg... | [
"def drop_filter(self, inplace=False):\n df = self if inplace else self.copy()\n df.select_nothing(name=FILTER_SELECTION_NAME)\n df._invalidate_caches()\n return df",
"def trimDf(df):\n cols = set(df.columns)\n\n cols.remove('exclamationCount') # bug in our feature extraction cod... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Lists all the uploads for a particular catalog. | def list_uploads_for_catalog_v0(self, catalog_id, **kwargs):
# type: (str, **Any) -> Union[ApiResponse, object, BadRequestError_a8ac8b44, ListUploadsResponse_59fc7728, Error_d660d58]
operation_name = "list_uploads_for_catalog_v0"
params = locals()
for key, val in six.iteritems(params['kw... | [
"def list_uploads(arn=None, nextToken=None):\n pass",
"def upload_list(self, uploader_id=None, uploader_name=None, source=None):\n params = {\n 'search[uploader_id]': uploader_id,\n 'search[uploader_name]': uploader_name,\n 'search[source]': source\n }\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Lists catalogs associated with a vendor. | def list_catalogs_for_vendor_v0(self, vendor_id, **kwargs):
# type: (str, **Any) -> Union[ApiResponse, object, ListCatalogsResponse_3dd2a983, BadRequestError_a8ac8b44, Error_d660d58]
operation_name = "list_catalogs_for_vendor_v0"
params = locals()
for key, val in six.iteritems(params['kw... | [
"def vendor_list(request):\n\n message = \"\"\n if request.GET.get('success') == 'true':\n message = \"Entry deleted successfully!\"\n elif request.GET.get('saved') == 'true':\n message = \"Entry saved successfully!\"\n\n search = request.GET.get('search')\n\n if search is None or searc... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Creates a new catalog based on information provided in the request. | def create_catalog_v0(self, create_catalog_request, **kwargs):
# type: (CreateCatalogRequest_f3cdf8bb, **Any) -> Union[ApiResponse, object, BadRequestError_a8ac8b44, CatalogDetails_912693fa, Error_d660d58]
operation_name = "create_catalog_v0"
params = locals()
for key, val in six.iterite... | [
"def create_catalog(self, catalog):\n # Create a dictionary of 'wrapped' values (i.e., db safe)\n wrapped = dict()\n \n # Get config from catalog record or nulls\n config = catalog.get('config', dict())\n\n # Owner comes from the request context\n if 'owner' in confi... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Lists the subscribers for a particular vendor. | def list_subscribers_for_development_events_v0(self, vendor_id, **kwargs):
# type: (str, **Any) -> Union[ApiResponse, object, ListSubscribersResponse_d1d01857, BadRequestError_a8ac8b44, Error_d660d58]
operation_name = "list_subscribers_for_development_events_v0"
params = locals()
for key... | [
"def vendor_list(request):\n\n message = \"\"\n if request.GET.get('success') == 'true':\n message = \"Entry deleted successfully!\"\n elif request.GET.get('saved') == 'true':\n message = \"Entry saved successfully!\"\n\n search = request.GET.get('search')\n\n if search is None or searc... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Creates a new subscriber resource for a vendor. | def create_subscriber_for_development_events_v0(self, create_subscriber_request, **kwargs):
# type: (CreateSubscriberRequest_a96d53b9, **Any) -> Union[ApiResponse, object, BadRequestError_a8ac8b44, Error_d660d58]
operation_name = "create_subscriber_for_development_events_v0"
params = locals()
... | [
"def create_subscription(self):\n\n self.clear_subscriptions()\n\n # creating new subscription\n r = self.fitbit_service.post('http://api.fitbit.com/1/user/-/apiSubscriptions/%s.json' % self.userid, data={}, header_auth=True)\n logging.info('Adding new subscription for user %s. The code: %s Message: %s'... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Associate skill with catalog. | def associate_catalog_with_skill_v0(self, skill_id, catalog_id, **kwargs):
# type: (str, str, **Any) -> Union[ApiResponse, object, BadRequestError_a8ac8b44, Error_d660d58]
operation_name = "associate_catalog_with_skill_v0"
params = locals()
for key, val in six.iteritems(params['kwargs'])... | [
"def add_skill(self):\n skill_obj = self.env['team.skill']\n # skill_obj.create([{'name': 'Wiring Repair'},\n # {'name': 'Measurements'},\n # {'name': 'Break Bleeding'}])\n skill_obj.create([{'name': 'Final Inspection'}])",
"def addSkill(self,... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Lists all the catalogs associated with a skill. | def list_catalogs_for_skill_v0(self, skill_id, **kwargs):
# type: (str, **Any) -> Union[ApiResponse, object, ListCatalogsResponse_3dd2a983, BadRequestError_a8ac8b44, Error_d660d58]
operation_name = "list_catalogs_for_skill_v0"
params = locals()
for key, val in six.iteritems(params['kwarg... | [
"def list_catalogs(self):\n return self._json_object_field_to_list(\n self._get_catalogs_json(), self.__MISSION_STRING)",
"def print_catalogs(self, cache=False):\n catalogs = self.list_catalogs(cache=cache)\n for catname in catalogs:\n print(\"{:30s} {:s}\".format(catna... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Create new upload Creates a new upload for a catalog and returns location to track the upload process. | def create_catalog_upload_v1(self, catalog_id, catalog_upload_request_body, **kwargs):
# type: (str, CatalogUploadBase_d7febd7, **Any) -> Union[ApiResponse, object, Error_fbe913d9, BadRequestError_f854b05]
operation_name = "create_catalog_upload_v1"
params = locals()
for key, val in six.... | [
"def create_catalog_upload_v1(self, catalog_id, catalog_upload_request_body, **kwargs):\n # type: (str, CatalogUploadBase, **Any) -> Union[ApiResponse, Error, BadRequestError]\n operation_name = \"create_catalog_upload_v1\"\n params = locals()\n for key, val in six.iteritems(params['kwar... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
The SMAPI Audit Logs API provides customers with an audit history of all SMAPI calls made by a developer or developers with permissions on that account. | def query_development_audit_logs_v1(self, get_audit_logs_request, **kwargs):
# type: (AuditLogsRequest_13316e3e, **Any) -> Union[ApiResponse, object, Error_fbe913d9, AuditLogsResponse_bbbe1918, BadRequestError_f854b05]
operation_name = "query_development_audit_logs_v1"
params = locals()
... | [
"def getAllActivityLog(self):\n url=self._v2BaseURL + \"/api/v2/activity/activityLog\"\n headers = {'Content-Type': \"application/json\", 'Accept': \"application/json\",\"icSessionID\":self._v2icSessionID}\n infapy.log.info(\"GetAllActivityLog URL - \" + url)\n infapy.log.info(\"API Head... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Get the list of inskill products for the vendor. | def get_isp_list_for_vendor_v1(self, vendor_id, **kwargs):
# type: (str, **Any) -> Union[ApiResponse, object, Error_fbe913d9, BadRequestError_f854b05, ListInSkillProductResponse_505e7307]
operation_name = "get_isp_list_for_vendor_v1"
params = locals()
for key, val in six.iteritems(params... | [
"def list_products(self):\n url = self.base_url\n # TODO add filtering support when holvi api supports it\n obdata = self.connection.make_get(url)\n return ProductList(obdata, self)",
"def get_isp_list_for_vendor_v1(self, vendor_id, **kwargs):\n # type: (str, **Any) -> Union[Api... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Creates a new inskill product for given vendorId. | def create_isp_for_vendor_v1(self, create_in_skill_product_request, **kwargs):
# type: (CreateInSkillProductRequest_816cf44b, **Any) -> Union[ApiResponse, object, Error_fbe913d9, ProductResponse_b388eec4, BadRequestError_f854b05]
operation_name = "create_isp_for_vendor_v1"
params = locals()
... | [
"def create_isp_for_vendor_v1(self, create_in_skill_product_request, **kwargs):\n # type: (CreateInSkillProductRequest, **Any) -> Union[ApiResponse, ProductResponse, Error, BadRequestError]\n operation_name = \"create_isp_for_vendor_v1\"\n params = locals()\n for key, val in six.iteritem... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Associates an inskill product with a skill. | def associate_isp_with_skill_v1(self, product_id, skill_id, **kwargs):
# type: (str, str, **Any) -> Union[ApiResponse, object, Error_fbe913d9, BadRequestError_f854b05]
operation_name = "associate_isp_with_skill_v1"
params = locals()
for key, val in six.iteritems(params['kwargs']):
... | [
"def add_skill(self):\n skill_obj = self.env['team.skill']\n # skill_obj.create([{'name': 'Wiring Repair'},\n # {'name': 'Measurements'},\n # {'name': 'Break Bleeding'}])\n skill_obj.create([{'name': 'Final Inspection'}])",
"def addSkill(self,... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Resets the entitlement(s) of the Product for the current user. | def reset_entitlement_for_product_v1(self, product_id, stage, **kwargs):
# type: (str, str, **Any) -> Union[ApiResponse, object, Error_fbe913d9, BadRequestError_f854b05]
operation_name = "reset_entitlement_for_product_v1"
params = locals()
for key, val in six.iteritems(params['kwargs']):... | [
"def reset_entitlement_for_product_v1(self, product_id, stage, **kwargs):\n # type: (str, str, **Any) -> Union[ApiResponse, Error, BadRequestError]\n operation_name = \"reset_entitlement_for_product_v1\"\n params = locals()\n for key, val in six.iteritems(params['kwargs']):\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Returns the inskill product definition for given productId. | def get_isp_definition_v1(self, product_id, stage, **kwargs):
# type: (str, str, **Any) -> Union[ApiResponse, object, InSkillProductDefinitionResponse_4aa468ff, Error_fbe913d9, BadRequestError_f854b05]
operation_name = "get_isp_definition_v1"
params = locals()
for key, val in six.iterite... | [
"def get_isp_definition_v1(self, product_id, stage, **kwargs):\n # type: (str, str, **Any) -> Union[ApiResponse, Error, InSkillProductDefinitionResponse, BadRequestError]\n operation_name = \"get_isp_definition_v1\"\n params = locals()\n for key, val in six.iteritems(params['kwargs']):\n... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Updates inskill product definition for given productId. Only development stage supported. | def update_isp_for_product_v1(self, product_id, stage, update_in_skill_product_request, **kwargs):
# type: (str, str, UpdateInSkillProductRequest_ee975cf1, **Any) -> Union[ApiResponse, object, Error_fbe913d9, BadRequestError_f854b05]
operation_name = "update_isp_for_product_v1"
params = locals()... | [
"def update_isp_for_product_v1(self, product_id, stage, update_in_skill_product_request, **kwargs):\n # type: (str, str, UpdateInSkillProductRequest, **Any) -> Union[ApiResponse, Error, BadRequestError]\n operation_name = \"update_isp_for_product_v1\"\n params = locals()\n for key, val i... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Get the summary information for an inskill product. | def get_isp_summary_v1(self, product_id, stage, **kwargs):
# type: (str, str, **Any) -> Union[ApiResponse, object, Error_fbe913d9, InSkillProductSummaryResponse_32ba64d7]
operation_name = "get_isp_summary_v1"
params = locals()
for key, val in six.iteritems(params['kwargs']):
... | [
"def get_isp_summary_v1(self, product_id, stage, **kwargs):\n # type: (str, str, **Any) -> Union[ApiResponse, InSkillProductSummaryResponse, Error]\n operation_name = \"get_isp_summary_v1\"\n params = locals()\n for key, val in six.iteritems(params['kwargs']):\n params[key] = ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
List all the historical versions of the given catalogId. | def list_interaction_model_catalog_versions_v1(self, catalog_id, **kwargs):
# type: (str, **Any) -> Union[ApiResponse, object, ListCatalogEntityVersionsResponse_aa31060e, StandardizedError_f5106a89, BadRequestError_f854b05]
operation_name = "list_interaction_model_catalog_versions_v1"
params = l... | [
"def get_version_history(self, **kwargs):\n response = self.sagemaker_session.sagemaker_client.list_model_card_versions(\n ModelCardName=self.name, **kwargs\n )\n\n return response[\"ModelCardVersionSummaryList\"]",
"def revision_history(self, uuid):\n return self.write.revi... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Create a new version of catalog entity for the given catalogId. | def create_interaction_model_catalog_version_v1(self, catalog_id, catalog, **kwargs):
# type: (str, VersionData_af79e8d3, **Any) -> Union[ApiResponse, object, StandardizedError_f5106a89, BadRequestError_f854b05]
operation_name = "create_interaction_model_catalog_version_v1"
params = locals()
... | [
"def create_interaction_model_catalog_version_v1(self, catalog_id, catalog, **kwargs):\n # type: (str, VersionData, **Any) -> Union[ApiResponse, StandardizedError, BadRequestError]\n operation_name = \"create_interaction_model_catalog_version_v1\"\n params = locals()\n for key, val in si... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Get catalog version data of given catalog version. | def get_interaction_model_catalog_version_v1(self, catalog_id, version, **kwargs):
# type: (str, str, **Any) -> Union[ApiResponse, object, StandardizedError_f5106a89, BadRequestError_f854b05, CatalogVersionData_86156352]
operation_name = "get_interaction_model_catalog_version_v1"
params = locals... | [
"def get_interaction_model_catalog_version_v1(self, catalog_id, version, **kwargs):\n # type: (str, str, **Any) -> Union[ApiResponse, StandardizedError, BadRequestError, CatalogVersionData]\n operation_name = \"get_interaction_model_catalog_version_v1\"\n params = locals()\n for key, val... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Get catalog values from the given catalogId & version. | def get_interaction_model_catalog_values_v1(self, catalog_id, version, **kwargs):
# type: (str, str, **Any) -> Union[ApiResponse, object, CatalogValues_ef5c3823, StandardizedError_f5106a89, BadRequestError_f854b05]
operation_name = "get_interaction_model_catalog_values_v1"
params = locals()
... | [
"def get_interaction_model_catalog_values_v1(self, catalog_id, version, **kwargs):\n # type: (str, str, **Any) -> Union[ApiResponse, StandardizedError, CatalogValues, BadRequestError]\n operation_name = \"get_interaction_model_catalog_values_v1\"\n params = locals()\n for key, val in six... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Creates a new Job Definition from the Job Definition request provided. This can be either a CatalogAutoRefresh, which supports timebased configurations for catalogs, or a ReferencedResourceVersionUpdate, which is used for slotTypes and Interaction models to be automatically updated on the dynamic update of their refere... | def create_job_definition_for_interaction_model_v1(self, create_job_definition_request, **kwargs):
# type: (CreateJobDefinitionRequest_e3d4c41, **Any) -> Union[ApiResponse, object, StandardizedError_f5106a89, BadRequestError_f854b05, CreateJobDefinitionResponse_efaa9a6f, ValidationErrors_d42055a1]
opera... | [
"def _build_create_job_definition_request(\n self,\n monitoring_schedule_name,\n job_definition_name,\n image_uri,\n latest_baselining_job_name=None,\n latest_baselining_job_config=None,\n existing_job_desc=None,\n endpoint_input=None,\n ground_truth_in... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
List all slot types for the vendor. | def list_interaction_model_slot_types_v1(self, vendor_id, **kwargs):
# type: (str, **Any) -> Union[ApiResponse, object, ListSlotTypeResponse_b426c805, StandardizedError_f5106a89, BadRequestError_f854b05]
operation_name = "list_interaction_model_slot_types_v1"
params = locals()
for key, v... | [
"def get_vehicle_types_assigned(cls, slot_number):\n try:\n slot = cls.objects.get(slot_number=slot_number)\n except cls.DoesNotExist:\n raise cls.InvalidSlotNumber\n\n return slot.vehicle_types_assigned.order_by('vehicle_capacity').all()",
"def get_potential_classes_for... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Create a new version of slot type within the given slotTypeId. | def create_interaction_model_slot_type_v1(self, slot_type, **kwargs):
# type: (DefinitionData_dad4effb, **Any) -> Union[ApiResponse, object, SlotTypeResponse_1ca513dc, StandardizedError_f5106a89, BadRequestError_f854b05]
operation_name = "create_interaction_model_slot_type_v1"
params = locals()
... | [
"def create_interaction_model_slot_type_version_v1(self, slot_type_id, slot_type, **kwargs):\n # type: (str, VersionData_faa770c8, **Any) -> Union[ApiResponse, object, StandardizedError_f5106a89, BadRequestError_f854b05]\n operation_name = \"create_interaction_model_slot_type_version_v1\"\n par... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Delete the slot type. | def delete_interaction_model_slot_type_v1(self, slot_type_id, **kwargs):
# type: (str, **Any) -> Union[ApiResponse, object, StandardizedError_f5106a89, BadRequestError_f854b05]
operation_name = "delete_interaction_model_slot_type_v1"
params = locals()
for key, val in six.iteritems(params... | [
"def delete(self):\n self.client.delete_inventory_type(self.global_id)",
"def delete_inventory(self, TypeName: str, SchemaDeleteOption: str = None, DryRun: bool = None, ClientToken: str = None) -> Dict:\n pass",
"def delete_slot_types(bot_name, slot_types):\n for slot_type in slot_types:\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Get the slot type definition. | def get_interaction_model_slot_type_definition_v1(self, slot_type_id, **kwargs):
# type: (str, **Any) -> Union[ApiResponse, object, StandardizedError_f5106a89, SlotTypeDefinitionOutput_20e87f7, BadRequestError_f854b05]
operation_name = "get_interaction_model_slot_type_definition_v1"
params = loc... | [
"def slot_type(self):\n return self.timeslot.type",
"def put_slot_type_response():\n return {\n \"name\": \"greeting slot\",\n 'checksum': 'chksum',\n 'description': 'slot type description',\n \"enumerationValues\": [\n {\n \"synonyms\": [\"string\"]... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Get the status of slot type resource and its subresources for a given slotTypeId. | def get_interaction_model_slot_type_build_status_v1(self, slot_type_id, update_request_id, **kwargs):
# type: (str, str, **Any) -> Union[ApiResponse, object, SlotTypeStatus_a293ebfc, StandardizedError_f5106a89, BadRequestError_f854b05]
operation_name = "get_interaction_model_slot_type_build_status_v1"
... | [
"def slot_status(self):\n\n slot_matrix = \"\"\n for slot in self.slots:\n slot_matrix += \"|\"\n for core in slot['cores']:\n if core == FREE:\n slot_matrix += \"-\"\n else:\n slot_matrix += \"+\"\n slot_... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
List all slot type versions for the slot type id. | def list_interaction_model_slot_type_versions_v1(self, slot_type_id, **kwargs):
# type: (str, **Any) -> Union[ApiResponse, object, StandardizedError_f5106a89, ListSlotTypeVersionResponse_7d552abf, BadRequestError_f854b05]
operation_name = "list_interaction_model_slot_type_versions_v1"
params = l... | [
"def get_interaction_model_slot_type_version_v1(self, slot_type_id, version, **kwargs):\n # type: (str, str, **Any) -> Union[ApiResponse, object, StandardizedError_f5106a89, BadRequestError_f854b05, SlotTypeVersionData_1f3ee474]\n operation_name = \"get_interaction_model_slot_type_version_v1\"\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Create a new version of slot type entity for the given slotTypeId. | def create_interaction_model_slot_type_version_v1(self, slot_type_id, slot_type, **kwargs):
# type: (str, VersionData_faa770c8, **Any) -> Union[ApiResponse, object, StandardizedError_f5106a89, BadRequestError_f854b05]
operation_name = "create_interaction_model_slot_type_version_v1"
params = loca... | [
"def create_interaction_model_slot_type_v1(self, slot_type, **kwargs):\n # type: (DefinitionData_dad4effb, **Any) -> Union[ApiResponse, object, SlotTypeResponse_1ca513dc, StandardizedError_f5106a89, BadRequestError_f854b05]\n operation_name = \"create_interaction_model_slot_type_v1\"\n params =... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Delete slot type version. | def delete_interaction_model_slot_type_version_v1(self, slot_type_id, version, **kwargs):
# type: (str, str, **Any) -> Union[ApiResponse, object, StandardizedError_f5106a89, BadRequestError_f854b05]
operation_name = "delete_interaction_model_slot_type_version_v1"
params = locals()
for ke... | [
"def delete_interaction_model_slot_type_v1(self, slot_type_id, **kwargs):\n # type: (str, **Any) -> Union[ApiResponse, object, StandardizedError_f5106a89, BadRequestError_f854b05]\n operation_name = \"delete_interaction_model_slot_type_v1\"\n params = locals()\n for key, val in six.iteri... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Get slot type version data of given slot type version. | def get_interaction_model_slot_type_version_v1(self, slot_type_id, version, **kwargs):
# type: (str, str, **Any) -> Union[ApiResponse, object, StandardizedError_f5106a89, BadRequestError_f854b05, SlotTypeVersionData_1f3ee474]
operation_name = "get_interaction_model_slot_type_version_v1"
params =... | [
"def create_interaction_model_slot_type_version_v1(self, slot_type_id, slot_type, **kwargs):\n # type: (str, VersionData_faa770c8, **Any) -> Union[ApiResponse, object, StandardizedError_f5106a89, BadRequestError_f854b05]\n operation_name = \"create_interaction_model_slot_type_version_v1\"\n par... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Get status for given importId. | def get_import_status_v1(self, import_id, **kwargs):
# type: (str, **Any) -> Union[ApiResponse, object, StandardizedError_f5106a89, ImportResponse_364fa39f]
operation_name = "get_import_status_v1"
params = locals()
for key, val in six.iteritems(params['kwargs']):
params[key] ... | [
"def GetImportStatus(self, table_name, import_id):\n conn = self._Connect()\n result = conn.Call(\n dict(method='bigquery.imports.get',\n parents=[('tables', table_name)],\n collection='imports',\n operation=bq.REST.GET,\n resource_name=import_id,\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Creates a new skill for given vendorId. | def create_skill_for_vendor_v1(self, create_skill_request, **kwargs):
# type: (CreateSkillRequest_92e74e84, **Any) -> Union[ApiResponse, object, CreateSkillResponse_2bad1094, StandardizedError_f5106a89, BadRequestError_f854b05]
operation_name = "create_skill_for_vendor_v1"
params = locals()
... | [
"def create_skill_for_vendor_v1(self, create_skill_request, **kwargs):\n # type: (CreateSkillRequest, **Any) -> Union[ApiResponse, StandardizedError, BadRequestError, CreateSkillResponse]\n operation_name = \"create_skill_for_vendor_v1\"\n params = locals()\n for key, val in six.iteritem... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
GetResourceSchema API provides schema for skill related resources. The schema returned by this API will be specific to vendor because it considers public beta features allowed for the vendor. | def get_resource_schema_v1(self, resource, vendor_id, **kwargs):
# type: (str, str, **Any) -> Union[ApiResponse, object, Error_fbe913d9, GetResourceSchemaResponse_9df87651, BadRequestError_f854b05]
operation_name = "get_resource_schema_v1"
params = locals()
for key, val in six.iteritems(... | [
"def get_schema(self):\n response = self.client.get(self._get_collection_url('schema'))\n\n return response.get('schema', {})",
"def get_schema(self):\n return self.client._perform_json(\n \"GET\", \"/projects/%s/streamingendpoints/%s/schema\" % (self.project_key, self.streamin... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Generates hosted skill repository credentials to access the hosted skill repository. | def generate_credentials_for_alexa_hosted_skill_v1(self, skill_id, hosted_skill_repository_credentials_request, **kwargs):
# type: (str, HostedSkillRepositoryCredentialsRequest_79a1c791, **Any) -> Union[ApiResponse, object, HostedSkillRepositoryCredentialsList_d39d5fdf, StandardizedError_f5106a89, BadRequestErr... | [
"def generate_credentials_for_alexa_hosted_skill_v1(self, skill_id, hosted_skill_repository_credentials_request, **kwargs):\n # type: (str, HostedSkillRepositoryCredentialsRequest, **Any) -> Union[ApiResponse, HostedSkillRepositoryCredentialsList, StandardizedError, BadRequestError]\n operation_name =... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
End beta test. End a beta test for a given Alexa skill. System will revoke the entitlement of each tester and send accessend notification email to them. | def end_beta_test_v1(self, skill_id, **kwargs):
# type: (str, **Any) -> Union[ApiResponse, object, Error_fbe913d9, BadRequestError_f854b05]
operation_name = "end_beta_test_v1"
params = locals()
for key, val in six.iteritems(params['kwargs']):
params[key] = val
del par... | [
"def end_beta_test_v1(self, skill_id, **kwargs):\n # type: (str, **Any) -> Union[ApiResponse, Error, BadRequestError]\n operation_name = \"end_beta_test_v1\"\n params = locals()\n for key, val in six.iteritems(params['kwargs']):\n params[key] = val\n del params['kwargs'... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Get beta test. Get beta test for a given Alexa skill. | def get_beta_test_v1(self, skill_id, **kwargs):
# type: (str, **Any) -> Union[ApiResponse, object, Error_fbe913d9, BetaTest_e826b162, BadRequestError_f854b05]
operation_name = "get_beta_test_v1"
params = locals()
for key, val in six.iteritems(params['kwargs']):
params[key] = ... | [
"def get_beta_test_v1(self, skill_id, **kwargs):\n # type: (str, **Any) -> Union[ApiResponse, BetaTest, Error, BadRequestError]\n operation_name = \"get_beta_test_v1\"\n params = locals()\n for key, val in six.iteritems(params['kwargs']):\n params[key] = val\n del param... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Create beta test. Create a beta test for a given Alexa skill. | def create_beta_test_v1(self, skill_id, **kwargs):
# type: (str, **Any) -> Union[ApiResponse, object, Error_fbe913d9, BadRequestError_f854b05]
operation_name = "create_beta_test_v1"
params = locals()
for key, val in six.iteritems(params['kwargs']):
params[key] = val
d... | [
"def create_beta_test_v1(self, skill_id, **kwargs):\n # type: (str, **Any) -> Union[ApiResponse, Error]\n operation_name = \"create_beta_test_v1\"\n params = locals()\n for key, val in six.iteritems(params['kwargs']):\n params[key] = val\n del params['kwargs']\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Update beta test. Update a beta test for a given Alexa skill. | def update_beta_test_v1(self, skill_id, **kwargs):
# type: (str, **Any) -> Union[ApiResponse, object, Error_fbe913d9, BadRequestError_f854b05]
operation_name = "update_beta_test_v1"
params = locals()
for key, val in six.iteritems(params['kwargs']):
params[key] = val
d... | [
"def update_beta_test_v1(self, skill_id, **kwargs):\n # type: (str, **Any) -> Union[ApiResponse, Error, BadRequestError]\n operation_name = \"update_beta_test_v1\"\n params = locals()\n for key, val in six.iteritems(params['kwargs']):\n params[key] = val\n del params['k... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Start beta test Start a beta test for a given Alexa skill. System will send invitation emails to each tester in the test, and add entitlement on the acceptance. | def start_beta_test_v1(self, skill_id, **kwargs):
# type: (str, **Any) -> Union[ApiResponse, object, Error_fbe913d9, BadRequestError_f854b05]
operation_name = "start_beta_test_v1"
params = locals()
for key, val in six.iteritems(params['kwargs']):
params[key] = val
del... | [
"def start_beta_test_v1(self, skill_id, **kwargs):\n # type: (str, **Any) -> Union[ApiResponse, Error, BadRequestError]\n operation_name = \"start_beta_test_v1\"\n params = locals()\n for key, val in six.iteritems(params['kwargs']):\n params[key] = val\n del params['kwa... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Add testers to an existing beta test. Add testers to a beta test for the given Alexa skill. System will send invitation email to each tester and add entitlement on the acceptance. | def add_testers_to_beta_test_v1(self, skill_id, testers_request, **kwargs):
# type: (str, TestersList_f8c0feda, **Any) -> Union[ApiResponse, object, Error_fbe913d9, BadRequestError_f854b05]
operation_name = "add_testers_to_beta_test_v1"
params = locals()
for key, val in six.iteritems(par... | [
"def add_testers_to_beta_test_v1(self, skill_id, testers_request, **kwargs):\n # type: (str, TestersList, **Any) -> Union[ApiResponse, Error, BadRequestError]\n operation_name = \"add_testers_to_beta_test_v1\"\n params = locals()\n for key, val in six.iteritems(params['kwargs']):\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
List testers. List all testers in a beta test for the given Alexa skill. | def get_list_of_testers_v1(self, skill_id, **kwargs):
# type: (str, **Any) -> Union[ApiResponse, object, Error_fbe913d9, BadRequestError_f854b05, ListTestersResponse_991ec8e9]
operation_name = "get_list_of_testers_v1"
params = locals()
for key, val in six.iteritems(params['kwargs']):
... | [
"def get_list_of_testers_v1(self, skill_id, **kwargs):\n # type: (str, **Any) -> Union[ApiResponse, Error, ListTestersResponse, BadRequestError]\n operation_name = \"get_list_of_testers_v1\"\n params = locals()\n for key, val in six.iteritems(params['kwargs']):\n params[key] =... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Remove testers from an existing beta test. Remove testers from a beta test for the given Alexa skill. System will send access end email to each tester and remove entitlement for them. | def remove_testers_from_beta_test_v1(self, skill_id, testers_request, **kwargs):
# type: (str, TestersList_f8c0feda, **Any) -> Union[ApiResponse, object, Error_fbe913d9, BadRequestError_f854b05]
operation_name = "remove_testers_from_beta_test_v1"
params = locals()
for key, val in six.ite... | [
"def remove_testers_from_beta_test_v1(self, skill_id, testers_request, **kwargs):\n # type: (str, TestersList, **Any) -> Union[ApiResponse, Error, BadRequestError]\n operation_name = \"remove_testers_from_beta_test_v1\"\n params = locals()\n for key, val in six.iteritems(params['kwargs']... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Request feedback from testers. Request feedback from the testers in a beta test for the given Alexa skill. System will send notification emails to testers to request feedback. | def request_feedback_from_testers_v1(self, skill_id, testers_request, **kwargs):
# type: (str, TestersList_f8c0feda, **Any) -> Union[ApiResponse, object, Error_fbe913d9, BadRequestError_f854b05]
operation_name = "request_feedback_from_testers_v1"
params = locals()
for key, val in six.ite... | [
"def request_feedback_from_testers_v1(self, skill_id, testers_request, **kwargs):\n # type: (str, TestersList, **Any) -> Union[ApiResponse, Error, BadRequestError]\n operation_name = \"request_feedback_from_testers_v1\"\n params = locals()\n for key, val in six.iteritems(params['kwargs']... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Send reminder to testers in a beta test. Send reminder to the testers in a beta test for the given Alexa skill. System will send invitation email to each tester and add entitlement on the acceptance. | def send_reminder_to_testers_v1(self, skill_id, testers_request, **kwargs):
# type: (str, TestersList_f8c0feda, **Any) -> Union[ApiResponse, object, Error_fbe913d9, BadRequestError_f854b05]
operation_name = "send_reminder_to_testers_v1"
params = locals()
for key, val in six.iteritems(par... | [
"def send_beta_role_email(action, user, email_params):\r\n if action == 'add':\r\n email_params['message'] = 'add_beta_tester'\r\n email_params['email_address'] = user.email\r\n email_params['full_name'] = user.profile.name\r\n\r\n elif action == 'remove':\r\n email_params['message... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Gets a specific certification resource. The response contains the review tracking information for a skill to show how much time the skill is expected to remain under review by Amazon. Once the review is complete, the response also contains the outcome of the review. Old certifications may not be available, however any ... | def get_certification_review_v1(self, skill_id, certification_id, **kwargs):
# type: (str, str, **Any) -> Union[ApiResponse, object, Error_fbe913d9, CertificationResponse_97fdaad, BadRequestError_f854b05]
operation_name = "get_certification_review_v1"
params = locals()
for key, val in si... | [
"def get_certification_review_v1(self, skill_id, certification_id, **kwargs):\n # type: (str, str, **Any) -> Union[ApiResponse, CertificationResponse, Error]\n operation_name = \"get_certification_review_v1\"\n params = locals()\n for key, val in six.iteritems(params['kwargs']):\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Get list of all certifications available for a skill, including information about past certifications and any ongoing certification. The default sort order is descending on skillSubmissionTimestamp for Certifications. | def get_certifications_list_v1(self, skill_id, **kwargs):
# type: (str, **Any) -> Union[ApiResponse, object, Error_fbe913d9, BadRequestError_f854b05, ListCertificationsResponse_f2a417c6]
operation_name = "get_certifications_list_v1"
params = locals()
for key, val in six.iteritems(params[... | [
"def certifications(self):\n return self._certifications",
"def get_certifications_list_v1(self, skill_id, **kwargs):\n # type: (str, **Any) -> Union[ApiResponse, ListCertificationsResponse, Error]\n operation_name = \"get_certifications_list_v1\"\n params = locals()\n for key, ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Deletes an existing experiment for a skill. | def delete_experiment_v1(self, skill_id, experiment_id, **kwargs):
# type: (str, str, **Any) -> Union[ApiResponse, object, StandardizedError_f5106a89, BadRequestError_f854b05]
operation_name = "delete_experiment_v1"
params = locals()
for key, val in six.iteritems(params['kwargs']):
... | [
"def delete_experiment(self, experiment_id):",
"def delete(ctx):\n user, project_name, _experiment = get_project_experiment_or_local(ctx.obj.get('project'),\n ctx.obj.get('experiment'))\n if not click.confirm(\"Are sure you want to delete ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Updates the exposure of an experiment that is in CREATED or RUNNING state. | def update_exposure_v1(self, skill_id, experiment_id, update_exposure_request, **kwargs):
# type: (str, str, UpdateExposureRequest_ce52ce53, **Any) -> Union[ApiResponse, object, StandardizedError_f5106a89, BadRequestError_f854b05]
operation_name = "update_exposure_v1"
params = locals()
f... | [
"def setExposureState(self):\n THRESHOLD = 0.00001\n value = self.data.get('CCD_EXPOSURE.CCD_EXPOSURE_VALUE')\n if self.device.CCD_EXPOSURE['state'] == 'Busy':\n if value is None:\n return False\n elif value <= THRESHOLD:\n if not self.isDownl... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Retrieves an existing experiment for a skill. | def get_experiment_v1(self, skill_id, experiment_id, **kwargs):
# type: (str, str, **Any) -> Union[ApiResponse, object, GetExperimentResponse_fcd92c35, StandardizedError_f5106a89, BadRequestError_f854b05]
operation_name = "get_experiment_v1"
params = locals()
for key, val in six.iteritem... | [
"def get_experiment(self):\n if hasattr(self,'experiment'):\n \n return self.experiment\n else:\n raise AttributeError('No experiment exists. First, select an experiment using select_experiment')",
"def get_experiment(self, experiment_id):",
"def get_experiment(sel... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Gets a list of all metric snapshots associated with this experiment id. The metric snapshots represent the metric data available for a time range. | def list_experiment_metric_snapshots_v1(self, skill_id, experiment_id, **kwargs):
# type: (str, str, **Any) -> Union[ApiResponse, object, StandardizedError_f5106a89, BadRequestError_f854b05, ListExperimentMetricSnapshotsResponse_bb18308b]
operation_name = "list_experiment_metric_snapshots_v1"
pa... | [
"def snapshots(self) -> SnapshotListing:\n return self.store.get_snapshots()",
"def list_snapshots(self):\n snapshots_raw = self.__compute_client.snapshots.list()\n\n snapshots = []\n for snapshot in snapshots_raw:\n snapshot_dict = {}\n snapshot_dict['name'] = sn... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Updates an existing experiment for a skill. Can only be called while the experiment is in CREATED state. | def update_experiment_v1(self, skill_id, experiment_id, update_experiment_request, **kwargs):
# type: (str, str, UpdateExperimentRequest_d8449813, **Any) -> Union[ApiResponse, object, StandardizedError_f5106a89, BadRequestError_f854b05]
operation_name = "update_experiment_v1"
params = locals()
... | [
"def update_experiment(\n self,\n experiment_id: str,\n metadata: Optional[Dict] = None,\n job_ids: Optional[List[str]] = None,\n notes: Optional[str] = None,\n tags: Optional[List[str]] = None,\n **kwargs: Any,\n ) -> None:\n pass",
"def test_skills_upda... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Retrieves the current user's customer treatment override for an existing A/B Test experiment. The current user must be under the same skill vendor of the requested skill id to have access to the resource. | def get_customer_treatment_override_v1(self, skill_id, experiment_id, **kwargs):
# type: (str, str, **Any) -> Union[ApiResponse, object, GetCustomerTreatmentOverrideResponse_f64f689f, StandardizedError_f5106a89, BadRequestError_f854b05]
operation_name = "get_customer_treatment_override_v1"
param... | [
"def set_customer_treatment_override_v1(self, skill_id, experiment_id, set_customer_treatment_override_request, **kwargs):\n # type: (str, str, SetCustomerTreatmentOverrideRequest_94022e79, **Any) -> Union[ApiResponse, object, StandardizedError_f5106a89, BadRequestError_f854b05]\n operation_name = \"s... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Adds the requesting user's customer treatment override to an existing experiment. The current user must be under the same skill vendor of the requested skill id to have access to the resource. Only the current user can attempt to add the override of their own customer account to an experiment. Can only be called before... | def set_customer_treatment_override_v1(self, skill_id, experiment_id, set_customer_treatment_override_request, **kwargs):
# type: (str, str, SetCustomerTreatmentOverrideRequest_94022e79, **Any) -> Union[ApiResponse, object, StandardizedError_f5106a89, BadRequestError_f854b05]
operation_name = "set_custo... | [
"def get_customer_treatment_override_v1(self, skill_id, experiment_id, **kwargs):\n # type: (str, str, **Any) -> Union[ApiResponse, object, GetCustomerTreatmentOverrideResponse_f64f689f, StandardizedError_f5106a89, BadRequestError_f854b05]\n operation_name = \"get_customer_treatment_override_v1\"\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Gets a list of all experiments associated with this skill id. | def list_experiments_v1(self, skill_id, **kwargs):
# type: (str, **Any) -> Union[ApiResponse, object, StandardizedError_f5106a89, BadRequestError_f854b05, ListExperimentsResponse_c5b07ecb]
operation_name = "list_experiments_v1"
params = locals()
for key, val in six.iteritems(params['kwar... | [
"def experiments(self) -> List[str]:\n if not self.experiment_container:\n self.populate_from_db()\n return [i[0] for i in self.experiment_container]",
"def list_experiments(self) -> Generator:\n for e in self.experiments:\n yield e.experiment_id",
"def experiments(sel... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Create a new experiment for a skill. | def create_experiment_v1(self, skill_id, create_experiment_request, **kwargs):
# type: (str, CreateExperimentRequest_abced22d, **Any) -> Union[ApiResponse, object, StandardizedError_f5106a89, BadRequestError_f854b05]
operation_name = "create_experiment_v1"
params = locals()
for key, val ... | [
"def add_skill(self):\n skill_obj = self.env['team.skill']\n # skill_obj.create([{'name': 'Wiring Repair'},\n # {'name': 'Measurements'},\n # {'name': 'Break Bleeding'}])\n skill_obj.create([{'name': 'Final Inspection'}])",
"def create_skill()... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
This is a synchronous API that invokes the Lambda or third party HTTPS endpoint for a given skill. A successful response will contain information related to what endpoint was called, payload sent to and received from the endpoint. In cases where requests to this API results in an error, the response will contain an err... | def invoke_skill_v1(self, skill_id, invoke_skill_request, **kwargs):
# type: (str, InvokeSkillRequest_8cf8aff9, **Any) -> Union[ApiResponse, object, InvokeSkillResponse_6f32f451, StandardizedError_f5106a89, BadRequestError_f854b05]
operation_name = "invoke_skill_v1"
params = locals()
for... | [
"def invoke_skill_end_point_v2(self, skill_id, stage, **kwargs):\n # type: (str, str, **Any) -> Union[ApiResponse, object, BadRequestError_765e0ac6, InvocationsApiResponse_3d7e3234, Error_ea6c1a5a]\n operation_name = \"invoke_skill_end_point_v2\"\n params = locals()\n for key, val in six... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Get the properties of an NLU annotation set Return the properties for an NLU annotation set. | def get_properties_for_nlu_annotation_sets_v1(self, skill_id, annotation_id, **kwargs):
# type: (str, str, **Any) -> Union[ApiResponse, object, Error_fbe913d9, GetNLUAnnotationSetPropertiesResponse_731f20d3, BadRequestError_f854b05]
operation_name = "get_properties_for_nlu_annotation_sets_v1"
pa... | [
"def getProperties(self):\n return self.metadataByProperty.keys()",
"def getPropertiesAll():",
"def update_properties_for_nlu_annotation_sets_v1(self, skill_id, annotation_id, update_nlu_annotation_set_properties_request, **kwargs):\n # type: (str, str, UpdateNLUAnnotationSetPropertiesRequest_b569f485... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
update the NLU annotation set properties. API which updates the NLU annotation set properties. Currently, the only data can be updated is annotation set name. | def update_properties_for_nlu_annotation_sets_v1(self, skill_id, annotation_id, update_nlu_annotation_set_properties_request, **kwargs):
# type: (str, str, UpdateNLUAnnotationSetPropertiesRequest_b569f485, **Any) -> Union[ApiResponse, object, Error_fbe913d9, BadRequestError_f854b05]
operation_name = "up... | [
"def update(self, _=None):\n raise UnsupportedOperation(\"Annotations are immutable and cannot be updated on the server.\")",
"def rename_annotations(args):\n\n project = ChildProject(args.source)\n\n perform_validation(project, require_success=True, ignore_recordings=True)\n\n am = AnnotationMana... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
List NLU annotation sets for a given skill. API which requests all the NLU annotation sets for a skill. Returns the annotationId and properties for each NLU annotation set. Developers can filter the results using locale. Supports paging of results. | def list_nlu_annotation_sets_v1(self, skill_id, **kwargs):
# type: (str, **Any) -> Union[ApiResponse, object, Error_fbe913d9, ListNLUAnnotationSetsResponse_5b1b0b6a, BadRequestError_f854b05]
operation_name = "list_nlu_annotation_sets_v1"
params = locals()
for key, val in six.iteritems(pa... | [
"def get_properties_for_nlu_annotation_sets_v1(self, skill_id, annotation_id, **kwargs):\n # type: (str, str, **Any) -> Union[ApiResponse, object, Error_fbe913d9, GetNLUAnnotationSetPropertiesResponse_731f20d3, BadRequestError_f854b05]\n operation_name = \"get_properties_for_nlu_annotation_sets_v1\"\n... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Create a new NLU annotation set for a skill which will generate a new annotationId. This is an API that creates a new NLU annotation set with properties and returns the annotationId. | def create_nlu_annotation_set_v1(self, skill_id, create_nlu_annotation_set_request, **kwargs):
# type: (str, CreateNLUAnnotationSetRequest_16b1430c, **Any) -> Union[ApiResponse, object, Error_fbe913d9, BadRequestError_f854b05, CreateNLUAnnotationSetResponse_b069cada]
operation_name = "create_nlu_annotat... | [
"def __gen_annoset_file(self):\n paula_id = '{}.{}.anno'.format(self.corpus_name, self.name)\n E, tree = gen_paula_etree(paula_id)\n\n slist = E('structList', {'type': 'annoSet'})\n # NOTE: we could group all the annotations into different structs\n # but I don't see the point. We... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Get top level information and status of a nlu evaluation. API which requests top level information about the evaluation like the current state of the job, status of the evaluation (if complete). Also returns data used to start the job, like the number of test cases, stage, locale, and start time. This should be conside... | def get_nlu_evaluation_v1(self, skill_id, evaluation_id, **kwargs):
# type: (str, str, **Any) -> Union[ApiResponse, object, Error_fbe913d9, GetNLUEvaluationResponse_2fb5e6ed, BadRequestError_f854b05]
operation_name = "get_nlu_evaluation_v1"
params = locals()
for key, val in six.iteritems... | [
"def get_result_for_nlu_evaluations_v1(self, skill_id, evaluation_id, **kwargs):\n # type: (str, str, **Any) -> Union[ApiResponse, object, Error_fbe913d9, GetNLUEvaluationResultsResponse_5ca1fa54, BadRequestError_f854b05]\n operation_name = \"get_result_for_nlu_evaluations_v1\"\n params = local... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Get test case results for a completed Evaluation. Paginated API which returns the test case results of an evaluation. This should be considered the 'expensive' operation while getNluEvaluation is 'cheap'. | def get_result_for_nlu_evaluations_v1(self, skill_id, evaluation_id, **kwargs):
# type: (str, str, **Any) -> Union[ApiResponse, object, Error_fbe913d9, GetNLUEvaluationResultsResponse_5ca1fa54, BadRequestError_f854b05]
operation_name = "get_result_for_nlu_evaluations_v1"
params = locals()
... | [
"def get(self, request):\n result = client.model_evaluation_list(request)\n return {'items': [n.to_dict() for n in result]}",
"def __get_evaluation_summary(self):\n self.logger.debug(\n f\"Getting summary for assignment {self.assignment_id}, eval_id {self.eval_id}\"\n )\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
List nlu evaluations run for a skill. API which requests recently run nlu evaluations started by a vendor for a skill. Returns the evaluation id and some of the parameters used to start the evaluation. Developers can filter the results using locale and stage. Supports paging of results. | def list_nlu_evaluations_v1(self, skill_id, **kwargs):
# type: (str, **Any) -> Union[ApiResponse, object, Error_fbe913d9, ListNLUEvaluationsResponse_7ef8d08f, BadRequestError_f854b05]
operation_name = "list_nlu_evaluations_v1"
params = locals()
for key, val in six.iteritems(params['kwarg... | [
"def get_result_for_nlu_evaluations_v1(self, skill_id, evaluation_id, **kwargs):\n # type: (str, str, **Any) -> Union[ApiResponse, object, Error_fbe913d9, GetNLUEvaluationResultsResponse_5ca1fa54, BadRequestError_f854b05]\n operation_name = \"get_result_for_nlu_evaluations_v1\"\n params = local... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Submit a target skill version to rollback to. Only one rollback or publish operation can be outstanding for a given skillId. | def rollback_skill_v1(self, skill_id, create_rollback_request, **kwargs):
# type: (str, CreateRollbackRequest_e7747a32, **Any) -> Union[ApiResponse, object, CreateRollbackResponse_5a2e8250, StandardizedError_f5106a89, BadRequestError_f854b05]
operation_name = "rollback_skill_v1"
params = locals(... | [
"def rollback_workflow(self, execution_id):\n raise NotImplementedError",
"def rollout_undo(self, target_revision=None):\n if target_revision is None:\n revision = {}\n else:\n revision = {\"revision\": target_revision}\n\n params = {\n \"kind\": \"Depl... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Get the rollback status of a skill given an associated rollbackRequestId. Use ~latest in place of rollbackRequestId to get the latest rollback status. | def get_rollback_for_skill_v1(self, skill_id, rollback_request_id, **kwargs):
# type: (str, str, **Any) -> Union[ApiResponse, object, StandardizedError_f5106a89, BadRequestError_f854b05, RollbackRequestStatus_71665366]
operation_name = "get_rollback_for_skill_v1"
params = locals()
for ke... | [
"def rollback_skill_v1(self, skill_id, create_rollback_request, **kwargs):\n # type: (str, CreateRollbackRequest_e7747a32, **Any) -> Union[ApiResponse, object, CreateRollbackResponse_5a2e8250, StandardizedError_f5106a89, BadRequestError_f854b05]\n operation_name = \"rollback_skill_v1\"\n params... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Simulate executing a skill with the given id. This is an asynchronous API that simulates a skill execution in the Alexa ecosystem given an utterance text of what a customer would say to Alexa. A successful response will contain a header with the location of the simulation resource. In cases where requests to this API r... | def simulate_skill_v1(self, skill_id, simulations_api_request, **kwargs):
# type: (str, SimulationsApiRequest_606eed02, **Any) -> Union[ApiResponse, object, Error_fbe913d9, BadRequestError_f854b05, SimulationsApiResponse_328955bc]
operation_name = "simulate_skill_v1"
params = locals()
fo... | [
"def simulate_skill_v1(self, skill_id, simulations_api_request, **kwargs):\n # type: (str, SimulationsApiRequest, **Any) -> Union[ApiResponse, SimulationsApiResponse, Error, BadRequestError]\n operation_name = \"simulate_skill_v1\"\n params = locals()\n for key, val in six.iteritems(para... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Get top level information and status of a Smart Home capability evaluation. Get top level information and status of a Smart Home capability evaluation. | def get_smart_home_capability_evaluation_v1(self, skill_id, evaluation_id, **kwargs):
# type: (str, str, **Any) -> Union[ApiResponse, object, Error_fbe913d9, BadRequestError_f854b05, GetSHCapabilityEvaluationResponse_d484531f]
operation_name = "get_smart_home_capability_evaluation_v1"
params = l... | [
"def test_get_hyperflex_capability_info_list(self):\n pass",
"def get(isamAppliance, check_mode=False, force=False):\n requires_model = None\n return isamAppliance.invoke_get(\"Retrieving web runtime component status\",\n \"/isam/runtime_components/\",requires_model... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
List Smart Home capability evaluation runs for a skill. List Smart Home capability evaluation runs for a skill. | def list_smarthome_capability_evaluations_v1(self, skill_id, stage, **kwargs):
# type: (str, str, **Any) -> Union[ApiResponse, object, Error_fbe913d9, ListSHCapabilityEvaluationsResponse_e6fe49d5, BadRequestError_f854b05]
operation_name = "list_smarthome_capability_evaluations_v1"
params = local... | [
"def get_smart_home_capability_evaluation_v1(self, skill_id, evaluation_id, **kwargs):\n # type: (str, str, **Any) -> Union[ApiResponse, object, Error_fbe913d9, BadRequestError_f854b05, GetSHCapabilityEvaluationResponse_d484531f]\n operation_name = \"get_smart_home_capability_evaluation_v1\"\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |