query stringlengths 9 9.05k | document stringlengths 10 222k | negatives listlengths 19 20 | metadata dict |
|---|---|---|---|
Sets the carrier_service_code of this TransportCall. | def carrier_service_code(self, carrier_service_code: CarrierServiceCode):
self._carrier_service_code = carrier_service_code | [
"def service_code(self, service_code):\n \n self._service_code = service_code",
"def carrier_service_code(self) -> CarrierServiceCode:\n return self._carrier_service_code",
"def shipping_carrier_code(self, shipping_carrier_code):\n\n self._shipping_carrier_code = shipping_carrier_cod... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Gets the carrier_voyage_number of this TransportCall. | def carrier_voyage_number(self) -> Object:
return self._carrier_voyage_number | [
"def carrier_voyage_number(self, carrier_voyage_number: Object):\n\n self._carrier_voyage_number = carrier_voyage_number",
"def transport_call_sequence_number(self) -> TransportCallSequenceNumber:\n return self._transport_call_sequence_number",
"def call_number(self):\n return self._call_nu... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Sets the carrier_voyage_number of this TransportCall. | def carrier_voyage_number(self, carrier_voyage_number: Object):
self._carrier_voyage_number = carrier_voyage_number | [
"def carrier_voyage_number(self) -> Object:\n return self._carrier_voyage_number",
"def carrier(self, carrier):\n self._carrier = carrier",
"def carrier_name(self, carrier_name):\n\n self._carrier_name = carrier_name",
"def transport_call_sequence_number(self, transport_call_sequence_numb... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Gets the transport_call_sequence_number of this TransportCall. | def transport_call_sequence_number(self) -> TransportCallSequenceNumber:
return self._transport_call_sequence_number | [
"def get_call_number(self):\n return self.call_num",
"def call_number(self):\n return self._call_number",
"def sequence_number(self):\n return self._sequence_number",
"def get_sequence_num(self):\n return self._sequence_num",
"def transport_call_sequence_number(self, transport_ca... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Sets the transport_call_sequence_number of this TransportCall. | def transport_call_sequence_number(self, transport_call_sequence_number: TransportCallSequenceNumber):
self._transport_call_sequence_number = transport_call_sequence_number | [
"def transport_call_sequence_number(self) -> TransportCallSequenceNumber:\n return self._transport_call_sequence_number",
"def call_number(self, call_number):\n\n self._call_number = call_number",
"def sequence_number(self, sequence_number):\n\n self._sequence_number = sequence_number",
"... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Gets the un_location_code of this TransportCall. | def un_location_code(self) -> UNLocationCode1:
return self._un_location_code | [
"def un_location_code(self, un_location_code: UNLocationCode1):\n\n self._un_location_code = un_location_code",
"def zip_code(self):\n return self._zip_code",
"def GetAbortCode(self):\n callResult = self._Call(\"GetAbortCode\", )\n\n if callResult is None:\n return None\n\... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Sets the un_location_code of this TransportCall. | def un_location_code(self, un_location_code: UNLocationCode1):
self._un_location_code = un_location_code | [
"def un_location_code(self) -> UNLocationCode1:\n return self._un_location_code",
"def antenna_location_code(self, antenna_location_code):\n\n self._antenna_location_code = antenna_location_code",
"def unit_code(self, unit_code):\n\n self._unit_code = unit_code",
"def unit_code(self, unit... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Gets the facility_code of this TransportCall. | def facility_code(self) -> FacilityCode:
return self._facility_code | [
"def facility_type_code(self) -> FacilityTypeCodeTRN:\n return self._facility_type_code",
"def facility_type_code(self, facility_type_code: FacilityTypeCodeTRN):\n\n self._facility_type_code = facility_type_code",
"def facility_code_list_provider(self) -> FacilityCodeListProvider:\n return ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Sets the facility_code of this TransportCall. | def facility_code(self, facility_code: FacilityCode):
self._facility_code = facility_code | [
"def facility_type_code(self, facility_type_code: FacilityTypeCodeTRN):\n\n self._facility_type_code = facility_type_code",
"def facility_code(self) -> FacilityCode:\n return self._facility_code",
"def facility_code_list_provider(self, facility_code_list_provider: FacilityCodeListProvider):\n\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Gets the facility_code_list_provider of this TransportCall. | def facility_code_list_provider(self) -> FacilityCodeListProvider:
return self._facility_code_list_provider | [
"def facility_code_list_provider(self, facility_code_list_provider: FacilityCodeListProvider):\n\n self._facility_code_list_provider = facility_code_list_provider",
"def facility_code(self) -> FacilityCode:\n return self._facility_code",
"def facility_type_code(self) -> FacilityTypeCodeTRN:\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Sets the facility_code_list_provider of this TransportCall. | def facility_code_list_provider(self, facility_code_list_provider: FacilityCodeListProvider):
self._facility_code_list_provider = facility_code_list_provider | [
"def facility_code_list_provider(self) -> FacilityCodeListProvider:\n return self._facility_code_list_provider",
"def facility_code(self, facility_code: FacilityCode):\n\n self._facility_code = facility_code",
"def facility_type_code(self, facility_type_code: FacilityTypeCodeTRN):\n\n self.... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Gets the facility_type_code of this TransportCall. | def facility_type_code(self) -> FacilityTypeCodeTRN:
return self._facility_type_code | [
"def facility_code(self) -> FacilityCode:\n return self._facility_code",
"def facility_type_code(self, facility_type_code: FacilityTypeCodeTRN):\n\n self._facility_type_code = facility_type_code",
"def type_code(self):\n return self._TYPE_CODE",
"def getTypeCode(self):\n return _li... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Sets the facility_type_code of this TransportCall. | def facility_type_code(self, facility_type_code: FacilityTypeCodeTRN):
self._facility_type_code = facility_type_code | [
"def facility_code(self, facility_code: FacilityCode):\n\n self._facility_code = facility_code",
"def facility_type_code(self) -> FacilityTypeCodeTRN:\n return self._facility_type_code",
"def type_code(self, type_code):\n self._type_code = type_code",
"def code_type(self, code_type):\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Gets the other_facility of this TransportCall. | def other_facility(self) -> OtherFacility:
return self._other_facility | [
"def other_facility(self, other_facility: OtherFacility):\n\n self._other_facility = other_facility",
"def get_other_end_trunk_party(self, otherDN):\n thisSiteTrunkParty = self.Call.findTrunkPartyToOtherSite(otherDN)\n return (thisSiteTrunkParty.DN.otherEndParty() if thisSiteTrunkParty and th... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Sets the other_facility of this TransportCall. | def other_facility(self, other_facility: OtherFacility):
self._other_facility = other_facility | [
"def other_facility(self) -> OtherFacility:\n return self._other_facility",
"def _set_custom_facility(gelf_dict, facility_value, record):\n gelf_dict.update({\"facility\": facility_value, '_logger': record.name})",
"def facility_name(self, facility_name):\n\n self._facility_name = facility_... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Gets the mode_of_transport of this TransportCall. | def mode_of_transport(self) -> ModeOfTransport:
return self._mode_of_transport | [
"def _get_operating_mode(self):\n if self.is_remote():\n return self._local_xbee_device.operating_mode\n return self._operating_mode",
"def mode_of_transport(self, mode_of_transport: ModeOfTransport):\n if mode_of_transport is None:\n raise ValueError(\"Invalid value for... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Sets the mode_of_transport of this TransportCall. | def mode_of_transport(self, mode_of_transport: ModeOfTransport):
if mode_of_transport is None:
raise ValueError("Invalid value for `mode_of_transport`, must not be `None`") # noqa: E501
self._mode_of_transport = mode_of_transport | [
"def mode_of_transport(self) -> ModeOfTransport:\n return self._mode_of_transport",
"def _set_mode(self, mode):\n self._spi_device.mode = mode",
"def transport(self, transport):\n\n self._transport = transport",
"def set_transmit_mode(self, mode):\n\n self.api.call_rc(\"port setTra... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Gets the vessel of this TransportCall. | def vessel(self) -> Vessel:
return self._vessel | [
"def vessel(self):\r\n if self.scene() == self.krpc.GameScene.flight:\r\n vessel = self.space_center.active_vessel # pylint: disable=no-member\r\n else:\r\n vessel = None\r\n\r\n return vessel",
"def get_vsolar(self):\n return self.read_register(4098, 1, 3)",
"... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Sets the vessel of this TransportCall. | def vessel(self, vessel: Vessel):
self._vessel = vessel | [
"def vessel(self) -> Vessel:\n return self._vessel",
"def vessel(self):\r\n if self.scene() == self.krpc.GameScene.flight:\r\n vessel = self.space_center.active_vessel # pylint: disable=no-member\r\n else:\r\n vessel = None\r\n\r\n return vessel",
"def SetPoint... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Initializes an ``NLPScoreType`` instance. | def __init__(self, score_name: str, word_list: List[str]):
score_name = score_name.lower()
self._score_name = score_name
if score_name in NLPSCORE_NO_WORD_LIST:
if word_list is not None:
raise TypeError(
"NLPScoreType with score_name {} requires it... | [
"def __init__(self, type, powerIndex):\n self.type_ = type\n self.powerIndex_ = powerIndex",
"def __init__(self, *args):\n _snap.TFltPr_swiginit(self, _snap.new_TFltPr(*args))",
"def __init__(self, *args):\n _snap.TIntFltPr_swiginit(self, _snap.new_TIntFltPr(*args))",
"def __init__... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Gets the string of the ``score_name`` argument. | def score_name(self) -> str:
return self._score_name | [
"def score_string(score):\n return str(score)",
"def name(self) -> str:\n return self._grades[\"name\"]",
"def name(self):\n msg = \"Getting the Score's name is deprecated.\"\n warnings.warn(msg, category=DeprecationWarning)\n return self._name",
"def get_name(self) -> str:",
... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Gets the string of the ``word_list`` argument. | def word_list(self) -> List[str]:
return self._word_list | [
"def get_word(self):\n return ''.join(l.letter for l in self.tiles)",
"def get_word_list(self, name):\n return self.store.get(name)[\"my_list\"]",
"def random_word(list_of_words):\n return random.choice(list_of_words)",
"def get_word(self):\n return self.__word",
"def list_name(self)... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Fills google form with information from the lists | def fill_listing(self):
self.driver.get(FORM)
for i in range(len(self.all_links)):
time.sleep(3)
question_1 = self.driver.find_element_by_xpath("""//*[@id="mG61Hd"]/div[2]/div/div[2]/div[1]/div/div/div[2]/div/div[1]/div/div[1]/input""")
question_1.send_keys(sel... | [
"def populate_the_contact_form():\n driver.find_element_by_name(\"name_field\").send_keys(\"Chris\")\n driver.find_element_by_name(\"address_field\").send_keys(\"Galaxy\")\n driver.find_element_by_name(\"postcode_field\").send_keys(\"P2D F3F\")\n driver.find_element_by_name(\"email_field\").send_keys(\"... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Generate quadratic heatmap z = (x centre_x)^2 + (y centre_y)^2 | def generate_quadratic_heatmap(batch_parameters, img_height=DEFAULT_HEIGHT, img_width=DEFAULT_WIDTH, return_params=False):
# if batch_parameters is None:
# centre_x, centre_y = get_initialization(img_height, img_width)
batch_size = batch_parameters.shape[0]
centre_x = batch_parameters[:, 0].unsquee... | [
"def generate_hcp_coordinates(n_x, n_y, n_z, scaling=1.0):\n return [((2 * i_x + ((i_y + i_z) % 2)) * 0.5 * scaling,\n _np.sqrt(3) * (i_y + (i_z % 2) / 3.0) * 0.5 * scaling,\n _np.sqrt(6) * i_z / 3.0 * scaling)\n for i_x in range(n_x) for i_y in range(n_y) for i_z in range(n_z)... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Function to tune hyperparameters using validation set | def hyperparameter_tune(X_train_all, y_train_all, X_val_all, y_val_all, hyperparameters, train_size=None):
# Initialize train_size to be the full train data if no parameters passed
if train_size is None:
train_size = len(X_train_all)
# Select Subset of Data
X_train = X_train_all[:train_size]
... | [
"def tune_parameters(self, model, param_set, train, predictor_var, target_var):\n \n grid_search = GridSearchCV(estimator = model, param_grid = param_set,n_jobs=-1, cv=5)\n grid_search.fit(train[predictor_var],train[target_var])\n \n print(grid_search.best_params_, grid_search.bes... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Deletes page from a website. | def delete(request, page_id):
page = Page.objects.get(pk=page_id)
error_messge = ""
if page:
try:
editor = page.get_editor()
if editor and editor.user.id != request.user.id:
# msg = 'You can\'t delete this page because %s is editing it' % (
# ... | [
"def _delete_page(self, pageId):",
"def delete_page(self, pageId):\n resp = self._delete_page(pageId)\n return resp",
"def DeletePage(self, index):\n page = self.__pages[index]\n self.RemovePage(index)\n page.Destroy()",
"def wiki_delete(self, page_id):\n return self.... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
List all pages of a website. | def list_pages(request):
context = RequestContext(request)
pages = request.website.get_pages()
return render_to_response("pages/list_pages.html", {"pages": pages}, context) | [
"def list_pages(self):\n raise NotImplementedError()",
"def fetch_all_urls(page, soup):\n page_urls = []\n try:\n write_content(page, soup.prettify().encode(\"utf-8\"))\n data = soup.findAll('div', attrs={'id': 'bodyContent'})\n for div in data:\n for link in div.findA... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
runs from the main HTTP server thread, or from write/flush() callback doesn't set/get Context; just checks if finish event was set by oboe_start() | def RequestHandler_finish(self):
if self.request._oboe_finish_ev and self.request._oboe_ctx and self.request._oboe_ctx.is_valid():
ev = self.request._oboe_finish_ev
ctx = self.request._oboe_ctx
if hasattr(self, 'get_status'): # recent Tornado
ev.add_info("Status", self.get_status... | [
"def run(self):\n self.initialize()\n\n # run the start callback\n tools.run_callback(\"start\", {'request': self._request})\n\n data = self._request.getData()\n pyhttp = self._request.getHttp()\n config = self._request.getConfiguration()\n\n # allow anyone else to h... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Tests that SMSes are actually sent using the Nexmo outgoing backend. | def test_sending_sms(self):
try:
from django.conf import settings
except ImportError:
self.fail(msg="No TEST_NUMBER found in settings!")
from rapidsms.router import send
from rapidsms.models import Connection, Backend
from random import randint
b... | [
"def test_sms_send(self):\n pass",
"def test_send_test_sms(self):\n pass",
"def test_send_sms_report(self):\n pass",
"def test_request_sms_recipient_export(self):\n pass",
"def test_send_sms_campaign_now(self):\n pass",
"def test_get_sms_message(self):\n pass",
... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Applies binary thresholding to the picture + gaussian blurring for smoothing. | def bin_thresh(img, threshold):
_, new_img = cv2.threshold(img, threshold, 255, cv2.THRESH_BINARY) # 255 is the max value
# make some smoothing to get rid of unnecessary ~splashes of color
# parameters are the width and height of gaussian kernel, and standard deviation in X and Y direction,
# sig... | [
"def adaptive_thresholding(img_data, threshold, radius):\n\n if img_data.dtype!=np.float:\n img_data = img_data.astype(np.float)\n\n img_blurred = ndi.gaussian_filter(img_data, sigma=radius/2.)\n img_corr = img_data - img_blurred\n img_bin = img_corr > threshold\n\n return img_bin",
"def smo... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Inverted binary thresholding + gaussian blurring. | def inv_bin_thresh(img, threshold):
# the 1st returned val = our threshold; if we use cv.THRESH_OTSU, it's optimal threshold val found by the algorithm
_, new_img = cv2.threshold(img, threshold, 255, cv2.THRESH_BINARY_INV)
# make some smoothing to get rid of unnecessary ~splashes of color
# parame... | [
"def bin_thresh(img, threshold):\r\n _, new_img = cv2.threshold(img, threshold, 255, cv2.THRESH_BINARY) # 255 is the max value\r\n\r\n # make some smoothing to get rid of unnecessary ~splashes of color\r\n # parameters are the width and height of gaussian kernel, and standard deviation in X and Y directio... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Reorder points in a rectangle in clockwise order to be consistent with OpenCV. | def reorder(pts):
# pts is a numpy array tha looks like [ [[numX numY]] [[num num]] [[num num]] [[num num]] ]
pts = pts.reshape((4, 2)) # make it look like [ [numX numY] [num num] [num num] [num num] ]
pts_new = np.zeros((4, 2), np.float32)
add = pts.sum(1) # array like [ numX+numY num+num num+n... | [
"def sort_clockwise_topleft_numpy(a):\n reshaped_a = a.reshape((-1, 4, 2))\n\n # sort the points based on their x-coordinates\n # shape = (box_nums, 4=points_nums, 1), the indices about 4 points\n x_ascend_indices = np.argsort(reshaped_a[..., 0:1], axis=1)\n # that's why take_along_axis's argument: a... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Find the playing card that is the closest to img. | def closest_card(model, img):
features = preprocess(img)
closest_match = sorted(model.values(), key=lambda x: img_compare(x[1], features))[0]
return closest_match[0] | [
"def _closest_front_opponent(self, raw_obs, o, target):\n delta = target - o\n min_d = None\n closest = None\n for p in raw_obs['right_team']:\n delta_opp = p - o\n if np.dot(delta, delta_opp) <= 0:\n continue\n d = self._object_distance(o,... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Create circuit definition from netlist file | def __init__(self, netlist_file):
with open(netlist_file, 'r') as f:
self.netlist = _parse_netlist(f)
self.G = _create_graph(self.netlist) | [
"def read_Netlist(ckt):\n\n netlist_file = parent_dir + '/benchmarks/'+ckt\n\n if not(os.path.isfile(netlist_file)):\n print(\"File not found please make sure file is in benchmarks folder\")\n sys.exit(0)\n\n # Read file into list line by line\n with open(netlist_file,'r') as f:\n l... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Construct graph from netlist | def _create_graph(netlist):
G = nx.Graph()
for t in netlist:
G.add_edges_from([(t.name, t.drain), (t.name, t.gate), (t.name, t.source)])
return G | [
"def makeGraphFromNetlist(inputNetlist):\n if type(inputNetlist) == str:\n myFile = open(inputNetlist,'r')\n netlist = json.load(myFile)\n myFile.close()\n elif type(inputNetlist) == list:\n netlist = inputNetlist\n \n #Initialize the lists of components\n Inputs = []\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Incrementing count for fish_species in fish dict. | def add_fish(self, fish_species):
if isinstance(fish_species, str):
self.fish[fish_species] += 1
else:
print("That doesn't look like a fish!") | [
"def add_fact(self, fact):\r\n found = False\r\n for key in self.facts:\r\n if fact == key:\r\n found = True\r\n self.facts[fact] += 1\r\n\r\n if not found or not self.facts:\r\n self.facts[fact] = 1",
"def num_animals_per_species(self):\n herbivore_count, carnivore_count =... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Iterate over and summarize self.fish dictionary. | def generate_fish_report(self):
if len(self.fish) == 0:
print('No fish in here, come back later')
for species, count in self.fish.items():
print(f'{species}: {count}') | [
"def fisher_info(self):\n return self.calc_suff_stats_moments(2)",
"def _per_supercls_summarize(self):\n\n per_super_class_result = {}\n superCats = self.FPParams.catSuperClsName\n\n for superCatId, superCat in enumerate(superCats):\n superCatKey = \"supercls-\" + superCat\n... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Iterate over and summarize self.animal dictionary. | def generate_animal_report(self):
print('ANIMALS IN ' + self.name)
for species, count in self.animals.items():
print(f'{species}: {count}') | [
"def get_animals(self):\n for animal in self.animals:\n print(animal)",
"def aging_animals(self):\n for herb in self.herbivore:\n herb.update_age()\n\n for carn in self.carnivore:\n carn.update_age()",
"def print_animal_info(self):",
"def total_number_of_a... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Iterate over and summarize self.plant dictionary. | def generate_plant_report(self):
print('PLANTS IN ' + self.name)
for species, count in self.plants.items():
print(f'{species}: {count}') | [
"def grow_plants(self):\n for plant_type in self.plants:\n for plant in plant_type.values():\n self.grow_plant(plant)\n self.update_plant_coverage(plant)",
"def generate_animal_report(self):\n print('ANIMALS IN ' + self.name)\n for species, count in se... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Returns the projection depth. The projection depth is the depth function associated with the StagelDonoho outlyingness. | def projection_depth(X, *, pointwise=False):
depth = outlyingness_to_depth(_stagel_donoho_outlyingness)
return depth(X, pointwise=pointwise) | [
"def GetDepth(*args, **kwargs):\n return _gdi_.DC_GetDepth(*args, **kwargs)",
"def depth_value(self):\n return self._depth_value",
"def get_numberOfProjections(self):\n self._nproj = len(self._projIndices)\n return self._nproj",
"def depth(self):\n return _libsbml.Dimensions... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Rendering portrayal of an agent | def agent_portrayal(agent):
portrayal = {"Shape": "circle",
"Filled": "true"
}
if agent.wealth > 0:
portrayal["Color"] = "red"
portrayal["Layer"] = 0
portrayal["r"] = 0.5
else:
portrayal["Color"] = "grey"
portrayal["Layer"] = 1
... | [
"def display(self, agent):\n agent.prepare()\n self.env.render()\n while not self.ended():\n self.perform(agent.act(self, verbose=True), render=True, delay=FAST)\n self.update()\n agent.update(self)\n self.env.close()",
"def display_agents(self):\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Sanitizes and sets the value. | def value(self, new_value):
self._value = self.sanitize(new_value) | [
"def sanitize_value(self, value):\n return value",
"def clean(self, value, model_instance):\n value = self.to_python(value)\n if value is not None:\n value = self.get_sanitizer()(value)\n self.validate(value, model_instance)\n self.run_validators(value)\n retur... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Parses and sanitizes the new value string. | def parse_and_set_value(self, new_value_str):
self.value = self.parse(new_value_str) | [
"def sanitize_value(self, value):\n return value",
"def value(self, new_value):\n self._value = self.sanitize(new_value)",
"def sanitiseValue(self, value):\r\n if len(value) == 0:\r\n raise ValueError(\"No value for option specified\")\r\n if self.STRING_REGEX.match(value)... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Returns a sanitized operand value between 21000. Defaults to 10. | def sanitize(cls, value):
return cls._get_value_inside_range(value, cls.MIN_VALUE,
cls.MAX_VALUE, cls.DEFAULT_VALUE) | [
"def _convert_greater_1000_less_4000(self, number):\n return int(str(number)[0]) * self.values_indo_to_roman[1000] + self.convert_to_roman(number%1000)",
"def sanitise_p_value(n_iter, p_val):\n if p_val == 0:\n p_val = \"< {}\".format(1 / n_iter)\n else:\n p_val = \"{:.4f}\".format(p_va... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Derive the XRP Ledger classic address for a given public key. See `Address Derivation | def derive_classic_address(public_key: str) -> str:
account_id = get_account_id(bytes.fromhex(public_key))
return addresscodec.encode_classic_address(account_id) | [
"def public_key_to_address(public_key: PublicKey) -> Address:\n key_bytes = public_key.format(compressed=False)\n return Address(keccak(key_bytes[1:])[-20:])",
"def _create_address_with_key(public_key: bytes) -> Optional['Address']:\n if isinstance(public_key, bytes):\n size = len(public_key)\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
>>> transform(["A1", "a12", "C3", "a"], ... pipelines = ["lower", "wordlen", "digit"]) ['aDIGIT', 'aDIGITDIGIT', 'cDIGIT'] >>> transform("A1 a12 C3", pipelines = ["lower", "digit"]) 'aDIGIT aDIGITDIGIT cDIGIT' >>> transform("Giving it to me generously", pipelines = ["tokenize", "stem"]) [u'give', 'it', 'to', 'me', u'ge... | def transform(stuff, pipelines=DEFAULT_PIPELINE_NAMES):
global _pipelines
for name in pipelines:
p = load_pipeline(name)
stuff = p.transform(stuff)
return stuff | [
"def preprocess(tokens):\n result = []\n for token in tokens:\n result.append(token.lower())\n return result",
"def transform_tags(tags:str):\n return tags.split(\" \")",
"def _apply_lowercase(sentence_tokens):\n return [token.lower() for token in sentence_tokens]",
"def tokenize(text, lowercase=Fa... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
If this project is at path, what's the current env prefix?. | def env_prefix(self, path):
if self.is_default:
return self.root # FIXME: Is this guaranteed to be the right one?
return os.sep.join([path, PROJECT_ENVS_FOLDER,
self.default_environment]) | [
"def get_environment_prefix(self):\n return self._prefix",
"def environment_prefix(self):\n return self._environment_prefix",
"def get_venv_path() -> Optional[str]:\n\n if hasattr(sys, \"real_prefix\") or sys.base_prefix != sys.prefix:\n return sys.prefix\n\n return None",
"def home... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Report curated stopwords lists in database | def query_stopwords_lists():
found = flask.g.db.find(tesserae.db.entities.StopwordsList.collection)
return flask.jsonify({'list_names': [a.name for a in found]}) | [
"def setStopwords(self, stopwords):",
"def retrieve_stopwords(request):\n stopwords = StopWord.objects.filter(user=request.user).order_by('query', 'word')\n\n params = {'stopwords': [s.get_stopword_dict() for s in stopwords]}\n return json_response_message('SUCCESS', '', params)",
"def getStopWords(sel... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Validates the given password in a request data. First, checks if it exists, then check if the password has the necessary length | def validate_password(data):
if "password" not in data:
return False
password = data["password"]
if len(password) < 4 or len(password) > 16:
return False
return True | [
"def validate_password(self,password):\n pass",
"def password_validator(form, field):\n\t# Convert string to list of characters\n\tpassword = list(field.data)\n\tpassword_length = len(password)\n\t# Count lowercase, uppercase and numbers\n\tlowers = uppers = digits = 0\n\tfor ch in password:\n\t\tif ch.isl... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Check if the given parameter is the the data request. If max or min parameters are present, it checks for the parameter length | def check_parameter(data, parameter, min_length=None, max_length=None):
if parameter not in data:
return False
if min_length is not None and len(data[parameter]) < min_length:
return False
if max_length is not None and len(data[parameter]) > max_length:
return False
return Tr... | [
"def _is_min_length(self, data, min_length):\n if len(data) >= min_length:\n return True\n return False",
"def _validate_length(data, min, max, err): # lint-amnesty, pylint: disable=redefined-builtin\n if len(data) < min or len(data) > max:\n raise errors.AccountDataBadLength(e... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Sets the slug of this Project. | def slug(self, slug):
if self.local_vars_configuration.client_side_validation and slug is None: # noqa: E501
raise ValueError("Invalid value for `slug`, must not be `None`") # noqa: E501
self._slug = slug | [
"def slug(self, slug):\n\n self._slug = slug",
"def set_slug(self, slug):\n if self.slug is None:\n self.slug = slug",
"def slug(self, slug):\n if slug is None:\n raise ValueError(\"Invalid value for `slug`, must not be `None`\")\n\n self._slug = slug",
"def s... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Use matplotlib to plot the distribution for this dataset and save to a distribution folder. | def VisualizeDistribution(dataset, distribution, title, filename):
# create the output directory if it doesn't exist
if not os.path.exists('distributions'):
os.mkdir('distributions')
if not os.path.exists('distributions/{}'.format(dataset)):
os.mkdir('distributions/{}'.format(dataset))
... | [
"def plot_and_save(data, prefix, name):\n plt.figure()\n plt.hist(data)\n plt.title(name)\n plt.xlabel(\"Value\")\n plt.ylabel(\"Frequency\")\n plt.savefig(prefix + name + '.png')\n plt.close()",
"def distributionplot(self, **kwargs) -> None:\n self.builder.get_distributionplot(**kwarg... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Plot function distributions for the dataset given the traces. Traces should contain all of the request types. | def FunctionDistribution(traces):
dataset = traces[0].dataset
# not implemented for xtrace
assert (not dataset == 'xtrace')
trace_functions = GetUniqueFunctions(traces)
# begin to keep track of the distributions
timestamp_distributions = {}
for function in trace_functions:
timestam... | [
"def RequestTypesDistribution(traces):\n dataset = traces[0].dataset\n trace_request_types = request_types_per_dataset[dataset]\n\n # begin to keep track of the distributions\n timestamp_distributions = {}\n for request_type in trace_request_types:\n timestamp_distributions[request_type] = []\... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Plot request type distributions for the dataset given the traces. Traces should contain all of the request types. | def RequestTypesDistribution(traces):
dataset = traces[0].dataset
trace_request_types = request_types_per_dataset[dataset]
# begin to keep track of the distributions
timestamp_distributions = {}
for request_type in trace_request_types:
timestamp_distributions[request_type] = []
for tra... | [
"def draw_dataset_distribution(dataset):\n # preparing data for plot.ly figure_factory distplot\n # the data should be an array of 4 each containing arrays of dataset features\n chart_data = [[], [], [], []]\n for i, er in enumerate(dataset):\n chart_data[0].append(dataset[i][0])\n chart_d... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Implementation of the EM algorithm for Gaussian Mixtures | def em(means=None, filename='sample-data.txt', visualize=False):
data = load_data(filename)
if means is None:
means = [min(data), max(data)]
num_of_mixtures, dimensions = len(data), 1 # Number of mixtures, dimension of mixture
num_of_measures = len(means) # Number of Gaussians
for iterati... | [
"def test_gaussian_em():\n fname = \"gmm-3-10-0.7.npz\"\n gmm = GaussianMixtureModel.generate( fname, 3, 3 )\n k, d, M, S, w = gmm.k, gmm.d, gmm.means, gmm.sigmas, gmm.weights\n N, n = 1e6, 1e5\n\n\n X = gmm.sample( N, n )\n\n algo = GaussianMixtureEM(k, d)\n\n def report( i, O_, lhood ):\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Returns GUID for UAttribute identifying assembly | def AssemblyGUID(*args):
return _XCAFDoc.xcafdoc_AssemblyGUID(*args) | [
"def Guid(self) -> _n_0_t_7:",
"def get_guid(path):\r\n\r\n #Type we are looking for\r\n coclass = comtypes._meta._coclass_meta\r\n\r\n #Get the typelib infos\r\n typelib = comtypes.client.GetModule(path)\r\n\r\n #For every attribute of the typelib stuffs, see if the attr matches the coclass\r\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
GetHandle(XCAFDoc_Area self) > Handle_XCAFDoc_Area | def GetHandle(self):
return _XCAFDoc.XCAFDoc_Area_GetHandle(self) | [
"def GetHandle(self):\n return _XCAFDoc.XCAFDoc_DocumentTool_GetHandle(self)",
"def GetHandle(self):\n return _XCAFDoc.XCAFDoc_Location_GetHandle(self)",
"def GetHandle(self):\n return _XCAFDoc.XCAFDoc_ShapeTool_GetHandle(self)",
"def GetHandle(self):\n return _XCAFDoc.XCAFDoc_Datu... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
GetHandle(XCAFDoc_Centroid self) > Handle_XCAFDoc_Centroid | def GetHandle(self):
return _XCAFDoc.XCAFDoc_Centroid_GetHandle(self) | [
"def GetHandle(self):\n return _XCAFDoc.XCAFDoc_Area_GetHandle(self)",
"def GetHandle(self):\n return _XCAFDoc.XCAFDoc_Location_GetHandle(self)",
"def GetHandle(self):\n return _XCAFDoc.XCAFDoc_ShapeTool_GetHandle(self)",
"def GetHandle(self):\n return _XCAFDoc.XCAFDoc_Datum_GetHan... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
GetHandle(XCAFDoc_Color self) > Handle_XCAFDoc_Color | def GetHandle(self):
return _XCAFDoc.XCAFDoc_Color_GetHandle(self) | [
"def GetHandle(self):\n return _XCAFDoc.XCAFDoc_ColorTool_GetHandle(self)",
"def GetHandle(self):\n return _Quantity.Quantity_HArray1OfColor_GetHandle(self)",
"def ColorIndex(self) -> int:",
"def GetDrawColor(self):\n ...",
"def _get_Color(self):\n return self._currentColor",
"... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Returns True if label belongs to a colortable and is a color definition | def IsColor(self, *args):
return _XCAFDoc.XCAFDoc_ColorTool_IsColor(self, *args) | [
"def HasColorName(self) -> bool:",
"def hasColor(self):\n \n pass",
"def IsByColor(self) -> bool:",
"def hasColor(self, color):\n if type(color) is not int:\n raise TypeError( \"Color must be of type int.\" )\n else:\n return color in self.__colordict__",
"def i... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Removes color from the colortable | def RemoveColor(self, *args):
return _XCAFDoc.XCAFDoc_ColorTool_RemoveColor(self, *args) | [
"def delete(self,plottable):\n if plottable in self.plottables:\n del self.plottables[plottable]\n if self.color > 0:\n self.color = self.color -1\n else:\n self.color =0",
"def clear_colors(self):\n for r in range(0, self.maze.get_nrows()):\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
GetHandle(XCAFDoc_ColorTool self) > Handle_XCAFDoc_ColorTool | def GetHandle(self):
return _XCAFDoc.XCAFDoc_ColorTool_GetHandle(self) | [
"def GetHandle(self):\n return _XCAFDoc.XCAFDoc_Color_GetHandle(self)",
"def GetHandle(self):\n return _XCAFDoc.XCAFDoc_LayerTool_GetHandle(self)",
"def GetHandle(self):\n return _Quantity.Quantity_HArray1OfColor_GetHandle(self)",
"def GetHandle(self):\n return _XCAFDoc.XCAFDoc_Mat... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
GetHandle(XCAFDoc_DataMapNodeOfDataMapOfShapeLabel self) > Handle_XCAFDoc_DataMapNodeOfDataMapOfShapeLabel | def GetHandle(self):
return _XCAFDoc.XCAFDoc_DataMapNodeOfDataMapOfShapeLabel_GetHandle(self) | [
"def GetHandle(self):\n return _XCAFDoc.XCAFDoc_ShapeMapTool_GetHandle(self)",
"def GetHandle(self):\n return _XCAFDoc.XCAFDoc_Datum_GetHandle(self)",
"def GetHandle(self):\n return _XCAFDoc.XCAFDoc_GraphNode_GetHandle(self)",
"def GetHandle(self):\n return _XCAFDoc.XCAFDoc_ShapeTo... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
GetHandle(XCAFDoc_Datum self) > Handle_XCAFDoc_Datum | def GetHandle(self):
return _XCAFDoc.XCAFDoc_Datum_GetHandle(self) | [
"def GetHandle(self):\n return _XCAFDoc.XCAFDoc_DocumentTool_GetHandle(self)",
"def GetHandle(self):\n return _XCAFDoc.XCAFDoc_Location_GetHandle(self)",
"def GetHandle(self):\n return _XCAFDoc.XCAFDoc_Area_GetHandle(self)",
"def handle(self) -> int:\n return self.obj.handle",
"d... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
GetHandle(XCAFDoc_DimTol self) > Handle_XCAFDoc_DimTol | def GetHandle(self):
return _XCAFDoc.XCAFDoc_DimTol_GetHandle(self) | [
"def GetHandle(self):\n return _XCAFDoc.XCAFDoc_DimTolTool_GetHandle(self)",
"def IsDimTol(self, *args):\n return _XCAFDoc.XCAFDoc_DimTolTool_IsDimTol(self, *args)",
"def DimTolTool(*args):\n return _XCAFDoc.XCAFDoc_DocumentTool_DimTolTool(*args)",
"def AddDimTol(self, *args):\n re... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Returns True if label belongs to a dimtoltable and is a DimTol definition | def IsDimTol(self, *args):
return _XCAFDoc.XCAFDoc_DimTolTool_IsDimTol(self, *args) | [
"def has_dimension(self, dim):\n\n return self.units.dimensions == dim",
"def is_label_dataframe(label, df):\n\n setdiff = set(label) - set(df.columns.tolist())\n\n if len(setdiff) == 0:\n return True\n else:\n return False",
"def IsDatum(self, *args):\n return _XCAFDoc.XCAF... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Adds a dimtol definition to a DGTtable and returns its label | def AddDimTol(self, *args):
return _XCAFDoc.XCAFDoc_DimTolTool_AddDimTol(self, *args) | [
"def test_get_dim_label_with_label(self):\n\n dim = self.oecd_datasets['oecd']['dimension']['id'][0]\n dims_df = pyjstat.get_dim_label(self.oecd_datasets['oecd'], dim)\n self.assertTrue(dims_df.iloc[0]['id'] == 'UNR')\n self.assertTrue(dims_df.iloc[-1]['label'] == 'Unemployment rate')",
... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Returns ShapeL defined for label DimTolL Returns False if the DimTolL is not in DGTtable | def GetRefShapeLabel(self, *args):
return _XCAFDoc.XCAFDoc_DimTolTool_GetRefShapeLabel(self, *args) | [
"def IsDimTol(self, *args):\n return _XCAFDoc.XCAFDoc_DimTolTool_IsDimTol(self, *args)",
"def is_lattice(self):\n return hasattr(self,\"uc\") and len(self.maximals())==1 and type(self.get_meet())!=str and type(self.get_join())!=str",
"def latticeType(self):\n return _ltDict[self.laueGroup]"... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Returns True if label belongs to a dimtoltable and is a Datum definition | def IsDatum(self, *args):
return _XCAFDoc.XCAFDoc_DimTolTool_IsDatum(self, *args) | [
"def has_data_labels(self):\n return self._element.dLbls is not None",
"def isDataLabel(self, label):\n\n if label in self._data:\n return True\n else:\n try:\n return self._getData(label) is not None\n except:\n return False",
... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Adds a datum definition to a DGTtable and returns its label | def AddDatum(self, *args):
return _XCAFDoc.XCAFDoc_DimTolTool_AddDatum(self, *args) | [
"def addDefinition(self, label:str, definition:str):\n try:\n self.definitions[label][\"definition\"] = definition\n except:\n self.definitions[label]= {\"definition\":definition}",
"def addData(self, label, value):\n self.__dataPoints__[str(label)] = value",
"def __ad... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
GetHandle(XCAFDoc_DimTolTool self) > Handle_XCAFDoc_DimTolTool | def GetHandle(self):
return _XCAFDoc.XCAFDoc_DimTolTool_GetHandle(self) | [
"def GetHandle(self):\n return _XCAFDoc.XCAFDoc_DimTol_GetHandle(self)",
"def DimTolTool(*args):\n return _XCAFDoc.XCAFDoc_DocumentTool_DimTolTool(*args)",
"def IsDimTol(self, *args):\n return _XCAFDoc.XCAFDoc_DimTolTool_IsDimTol(self, *args)",
"def GetHandle(self):\n return _XCAFD... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Creates (if it does not exist) LayerTool attribute on LayersLabel(). | def LayerTool(*args):
return _XCAFDoc.XCAFDoc_DocumentTool_LayerTool(*args) | [
"def NewLayer(self, layer):\n pass",
"def add_label(self, text, layer, offset=[0,0],zoom=1):\n debug.info(3,\"add label \" + text + \" \" + str(layer) + \" \" + str(offset))\n # negative layers indicate \"unused\" layers in a given technology\n layerNumber = techlayer[layer]\n if ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Creates (if it does not exist) DimTolTool attribute on DGTsLabel(). | def DimTolTool(*args):
return _XCAFDoc.XCAFDoc_DocumentTool_DimTolTool(*args) | [
"def AddDimTol(self, *args):\n return _XCAFDoc.XCAFDoc_DimTolTool_AddDimTol(self, *args)",
"def test_create_metering_label(self):\r\n resource = 'metering_label'\r\n cmd = metering.CreateMeteringLabel(\r\n test_cli20.MyApp(sys.stdout), None)\r\n name = 'my label'\r\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
GetHandle(XCAFDoc_DocumentTool self) > Handle_XCAFDoc_DocumentTool | def GetHandle(self):
return _XCAFDoc.XCAFDoc_DocumentTool_GetHandle(self) | [
"def GetHandle(self):\n return _XCAFDoc.XCAFDoc_LayerTool_GetHandle(self)",
"def GetHandle(self):\n return _XCAFDoc.XCAFDoc_ShapeTool_GetHandle(self)",
"def GetHandle(self):\n return _XCAFDoc.XCAFDoc_Location_GetHandle(self)",
"def GetHandle(self):\n return _XCAFDoc.XCAFDoc_DimTolT... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
class methods working on the node =================================== Shortcut to search a Graph node attribute with default GraphID. Returns true if found. | def Find(*args):
return _XCAFDoc.XCAFDoc_GraphNode_Find(*args) | [
"def find_node_by_id(self, label, key):\r\n\t\tnds = self.graph.data(\"MATCH (nd:{} {{neo_id: '{}'}}) RETURN nd\".format(label,key))\r\n\r\n\t\tif nds:\r\n\t\t\treturn nds[0]['nd']\r\n\t\telse:\r\n\t\t\treturn None",
"def nodeWithLabel(self, label):\r\n for nt in self.listNodes.keys(): \t# for a... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
returns True if is father of . | def IsFather(self, *args):
return _XCAFDoc.XCAFDoc_GraphNode_IsFather(self, *args) | [
"def folha(tree):\n if tree.filhos is None:\n return True\n return False",
"def isChild(self):\n \n pass",
"def hasSiblings():",
"def _is_parent(a, b):\n # type: (PredContext, PredContext) -> bool\n while b and a is not b:\n b = getattr(b, 'parent', None)\n return a is b... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
GetHandle(XCAFDoc_GraphNode self) > Handle_XCAFDoc_GraphNode | def GetHandle(self):
return _XCAFDoc.XCAFDoc_GraphNode_GetHandle(self) | [
"def GetHandle(self):\n return _XCAFDoc.XCAFDoc_SequenceNodeOfGraphNodeSequence_GetHandle(self)",
"def GetHandle(self):\n return _XCAFDoc.XCAFDoc_Datum_GetHandle(self)",
"def handle(self) -> int:\n return self.obj.handle",
"def ObjectHandle(self):\n return self._ObjectHandle",
"d... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Finds a Layer definition in a Layertable and returns its label if found Returns False if Layer is not found in Layertable | def FindLayer(self, *args):
return _XCAFDoc.XCAFDoc_LayerTool_FindLayer(self, *args) | [
"def find_layer_by_name(self, layer_name):\n return next(x for x in self.layers if x.name == layer_name)",
"def get_layer(self, layer_name):\n for layer in self.data.layers:\n if layer.name == layer_name: return layer",
"def findLayer(job, layer):\n return Layer(Cuebot.getStub('layer... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Adds a Layer definition to a Layertable and returns its label (returns existing label if the same Layer is already defined) | def AddLayer(self, *args):
return _XCAFDoc.XCAFDoc_LayerTool_AddLayer(self, *args) | [
"def AddLayer(self, layer):\n pass",
"def add_layer(self, layer):\n idx = len(self.dict_topo)\n idx += 1\n self.dict_topo[idx] = layer",
"def add_label(self, text, layer, offset=[0,0],zoom=1):\n debug.info(3,\"add label \" + text + \" \" + str(layer) + \" \" + str(offset))\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Set the visibility of layer. If layer is invisible when on it's layer will set UAttribute with corresponding GUID. | def SetVisibility(self, *args):
return _XCAFDoc.XCAFDoc_LayerTool_SetVisibility(self, *args) | [
"def set_layer_visibility(self, visible, layer):\n cmd = self.get_last_command()\n if isinstance(cmd, command.SetLayerVisibility) and cmd.layer is layer:\n self.update_last_command(visible=visible)\n else:\n self.do(command.SetLayerVisibility(self, visible, layer))",
"de... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
GetHandle(XCAFDoc_LayerTool self) > Handle_XCAFDoc_LayerTool | def GetHandle(self):
return _XCAFDoc.XCAFDoc_LayerTool_GetHandle(self) | [
"def GetHandle(self):\n return _XCAFDoc.XCAFDoc_MaterialTool_GetHandle(self)",
"def GetHandle(self):\n return _XCAFDoc.XCAFDoc_DocumentTool_GetHandle(self)",
"def GetHandle(self):\n return _XCAFDoc.XCAFDoc_ColorTool_GetHandle(self)",
"def LayerTool(*args):\n return _XCAFDoc.XCAFDoc... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
GetHandle(XCAFDoc_Location self) > Handle_XCAFDoc_Location | def GetHandle(self):
return _XCAFDoc.XCAFDoc_Location_GetHandle(self) | [
"def GetHandle(self):\n return _XCAFDoc.XCAFDoc_DocumentTool_GetHandle(self)",
"def GetHandle(self):\n return _XCAFDoc.XCAFDoc_Area_GetHandle(self)",
"def GetHandlePosition(self):\n ...",
"def GetHandle(self):\n return _XCAFDoc.XCAFDoc_ShapeTool_GetHandle(self)",
"def GetHandle(s... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
GetHandle(XCAFDoc_Material self) > Handle_XCAFDoc_Material | def GetHandle(self):
return _XCAFDoc.XCAFDoc_Material_GetHandle(self) | [
"def GetHandle(self):\n return _XCAFDoc.XCAFDoc_MaterialTool_GetHandle(self)",
"def GetHandle(self):\n return _XCAFDoc.XCAFDoc_DocumentTool_GetHandle(self)",
"def GetHandle(self):\n return _XCAFDoc.XCAFDoc_Color_GetHandle(self)",
"def GetHandle(self):\n return _XCAFDoc.XCAFDoc_Shap... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
GetHandle(XCAFDoc_MaterialTool self) > Handle_XCAFDoc_MaterialTool | def GetHandle(self):
return _XCAFDoc.XCAFDoc_MaterialTool_GetHandle(self) | [
"def GetHandle(self):\n return _XCAFDoc.XCAFDoc_Material_GetHandle(self)",
"def GetHandle(self):\n return _XCAFDoc.XCAFDoc_LayerTool_GetHandle(self)",
"def GetHandle(self):\n return _XCAFDoc.XCAFDoc_ColorTool_GetHandle(self)",
"def GetHandle(self):\n return _XCAFDoc.XCAFDoc_Documen... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Find referred material and return density from it if no material > return 0 | def XCAFDoc_MaterialTool_GetDensityForShape(*args):
return _XCAFDoc.XCAFDoc_MaterialTool_GetDensityForShape(*args) | [
"def Density(material):\n if material == \"mild\":\n return 7850.0\n else:\n if material == \"al\":\n return 2700.0\n else:\n raise ValueError(\"Invalid material `\"+material+\"'\")",
"def getDominantMaterial(\n objects: List[ArmiObject], typeSpec: TypeSpec = No... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
GetHandle(XCAFDoc_SequenceNodeOfGraphNodeSequence self) > Handle_XCAFDoc_SequenceNodeOfGraphNodeSequence | def GetHandle(self):
return _XCAFDoc.XCAFDoc_SequenceNodeOfGraphNodeSequence_GetHandle(self) | [
"def GetHandle(self):\n return _Bnd.Bnd_SequenceNodeOfSeqOfBox_GetHandle(self)",
"def GetHandle(self):\n return _XCAFDoc.XCAFDoc_GraphNode_GetHandle(self)",
"def _get_node(self, seq):\n cur_node = self.root\n for token_id in seq:\n children = cur_node.edges\n if... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Checks whether shape is subshape of shape stored on label shapeL | def IsSubShape(self, *args):
return _XCAFDoc.XCAFDoc_ShapeMapTool_IsSubShape(self, *args) | [
"def IsSubShape(self, *args):\n return _XCAFDoc.XCAFDoc_ShapeTool_IsSubShape(self, *args)",
"def is_shape(sym,shape):\n return get_shape(sym)==shape",
"def isValidPcbShape(g):\n return g.GetShape() != pcbnew.S_SEGMENT or g.GetLength() > 0",
"def has_shape(self):\n if self.shape is None: re... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
GetHandle(XCAFDoc_ShapeMapTool self) > Handle_XCAFDoc_ShapeMapTool | def GetHandle(self):
return _XCAFDoc.XCAFDoc_ShapeMapTool_GetHandle(self) | [
"def GetHandle(self):\n return _XCAFDoc.XCAFDoc_ShapeTool_GetHandle(self)",
"def GetHandle(self):\n return _XCAFDoc.XCAFDoc_LayerTool_GetHandle(self)",
"def GetHandle(self):\n return _XCAFDoc.XCAFDoc_DataMapNodeOfDataMapOfShapeLabel_GetHandle(self)",
"def GetHandle(self):\n return ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Returns True if the label represents a shape (simple shape, assembly or reference) | def IsShape(*args):
return _XCAFDoc.XCAFDoc_ShapeTool_IsShape(*args) | [
"def XCAFDoc_ShapeTool_IsShape(*args):\n return _XCAFDoc.XCAFDoc_ShapeTool_IsShape(*args)",
"def is_shape(sym,shape):\n return get_shape(sym)==shape",
"def has_shape(self):\n if self.shape is None: return False\n else:\n return True",
"def has_shape(a):\n try:\n a.shape\... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Return true if is a located instance of other shape i.e. reference | def IsReference(*args):
return _XCAFDoc.XCAFDoc_ShapeTool_IsReference(*args) | [
"def __eq__(self, other):\n result = False\n if isinstance(other, Shape) and (self.area == other.area):\n return True\n else:\n return False",
"def _has_handle_reference(self, classname, handle):\n if classname == 'Place':\n return self.place == handle\... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Returns True if the label is a label of compound, i.e. contains some sublabels This is relevant only if IsShape() is True | def IsCompound(*args):
return _XCAFDoc.XCAFDoc_ShapeTool_IsCompound(*args) | [
"def isCompound(self):\n \n pass",
"def multilabel_(self):\n return self.label_binarizer_.y_type_.startswith('multilabel')",
"def _is_label(self, words):\n if words[0] == 'label':\n if len(words) != 2:\n raise SyntaxError(\"File line {}: Invalid number of argume... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Return true if is subshape of the toplevel shape | def IsSubShape(self, *args):
return _XCAFDoc.XCAFDoc_ShapeTool_IsSubShape(self, *args) | [
"def IsSubShape(self, *args):\n return _XCAFDoc.XCAFDoc_ShapeMapTool_IsSubShape(self, *args)",
"def has_shape(node):\n allowed_shapes = (\n pm.nt.Mesh,\n pm.nt.NurbsCurve,\n pm.nt.NurbsSurface\n )\n\n has_it = False\n\n children = node.getChildren()\n while len(children)... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Returns the label corresponding to shape S (searches among toplevel shapes, not including subcomponents of assemblies) If findInstance is False (default), searches for the nonlocated shape (i.e. among original shapes) If findInstance is True, searches for the shape with the same location, including shape instances Retu... | def FindShape(self, *args):
return _XCAFDoc.XCAFDoc_ShapeTool_FindShape(self, *args) | [
"def Search_lable(self, address):\r\n ret = False\r\n for i in self.Labels_names:\r\n if self.Labels_names[i] == address:\r\n return True\r\n return ret",
"def _findLabel(self, label):\n if self.label == label:\n return self\n else:\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Removes shape (whole label and all its sublabels) If removeCompletely is true, removes complete shape If removeCompletely is false, removes instance(location) only Returns False (and does nothing) if shape is not free or is not toplevel shape | def RemoveShape(self, *args):
return _XCAFDoc.XCAFDoc_ShapeTool_RemoveShape(self, *args) | [
"def remove_shape(self, shape):\r\n cp.cpSpaceRemoveShape(self._space, shape._shape)",
"def RemoveShape(self, object):\n if object in self.children:\n self.children.remove(object)",
"def remove_shape(self, shape: Shape):\r\n remain = list(filter(lambda x: x != shape, self.__shape... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Returns a sequence of all toplevel shapes which are free (i.e. not referred by any other) | def GetFreeShapes(self, *args):
return _XCAFDoc.XCAFDoc_ShapeTool_GetFreeShapes(self, *args) | [
"def get_shapes(object_, fullPathState=False, noIntermediateState=True):\n\n object_shapes = []\n shapes = cmds.listRelatives(object_, fullPath=fullPathState, shapes=True, noIntermediate=noIntermediateState)\n if shapes is not None:\n object_shapes = shapes\n\n return object_shapes",
"def free ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Update an assembly at label | def UpdateAssembly(self, *args):
return _XCAFDoc.XCAFDoc_ShapeTool_UpdateAssembly(self, *args) | [
"def UpdateLabel(self) -> _n_6_t_0:",
"def update(self, src, labels): # real signature unknown; restored from __doc__\n pass",
"def update(self):\n args = {attr: getattr(self, attr) for attr in self.to_update}\n args[\"id\"] = self.id\n _perform_command(self.owner, \"label_update\", ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Adds a label for subshape of shape stored on label shapeL Returns Null label if it is not subshape | def AddSubShape(self, *args):
return _XCAFDoc.XCAFDoc_ShapeTool_AddSubShape(self, *args) | [
"def set_label_shape(label):\n label.set_shape([1])\n return label",
"def label(self):\n return self._label_shape",
"def draw_shape_label(self, label, xform, colour):\n #TODO deal with alignment, rotation\n pos = xform.chain(Point(label.x, label.y))\n self.canvas.text((pos.x, p... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Returns True if the label is a label of external references, i.e. there are some reference on the nostep files, which are described in document only their names | def IsExternRef(*args):
return _XCAFDoc.XCAFDoc_ShapeTool_IsExternRef(*args) | [
"def is_referendum(self):\n return self.ballot_paper_id.startswith(\"ref.\")",
"def is_ref_known(self):\r\n \r\n if \"N\" in self.ref:\r\n return False\r\n else:\r\n return True",
"def __contains__(self, doc_label):\n return doc_label in self.... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Sets the SHUO structure between upper_usage and next_usage create multylevel (if number of labels > 2) SHUO from first to last Initialise out by main upper_usage SHUO attribute. Returns False if some of labels in not component label | def SetSHUO(self, *args):
return _XCAFDoc.XCAFDoc_ShapeTool_SetSHUO(self, *args) | [
"def do_usage(self, usage_location):\n if not usage_location:\n print(f\"no usage location specified\")\n return False\n usage_node = self.graph.get(usage_location)\n if not usage_node:\n usage_node = Node(usage_location)\n self.graph[usage_location] ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Searchs the SHUO by labels of components from upper_usage componet to next_usage Returns null attribute if no SHUO found | def FindSHUO(*args):
return _XCAFDoc.XCAFDoc_ShapeTool_FindSHUO(*args) | [
"def XCAFDoc_ShapeTool_FindSHUO(*args):\n return _XCAFDoc.XCAFDoc_ShapeTool_FindSHUO(*args)",
"def find_huc(source, shape, in_crs, hint, shrink_factor=1.e-5):\n def _in_huc(shply, huc_shply):\n \"\"\"Checks whether shp is in HUC\"\"\"\n if huc_shply.contains(shply):\n return 2\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |