query stringlengths 9 9.05k | document stringlengths 10 222k | negatives listlengths 19 20 | metadata dict |
|---|---|---|---|
Get overlapping public methods between NaT and another class. | def _get_overlap_public_nat_methods(klass, as_tuple=False):
nat_names = dir(NaT)
klass_names = dir(klass)
overlap = [
x
for x in nat_names
if x in klass_names and not x.startswith("_") and callable(getattr(klass, x))
]
# Timestamp takes precedence over Timedelta in terms of... | [
"def get_overridden_methods(cls: type, obj: Type['spines.base.BaseObject']):\n common = cls.__dict__.keys() & obj.__class__.__dict__.keys()\n return [\n m for m in common if cls.__dict__[m] != obj.__class__.__dict__[m]\n and callable(cls.__dict__[m])\n ]",
"def get_class_methods(class_ast):... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Internal method to select the model given a task. User would not need to call this normally. | def _select_model(self):
available_models = self.params["task"][self.task]
models_list = list(available_models.keys())
models_list.append("Return to task selection")
# prompt CLI models options
terminal_menu = TerminalMenu(models_list, preview_command=self._preview_model... | [
"def model(self):\n return self.tasks[self.main_task].model",
"def _get_select_item(self):\n\t\ttry:\n\t\t\titem_properties = self.tree.item( self.tree.focus() )\n\t\t\tid = int(item_properties['values'][0])\n\t\t\ttask = Task(id)\n\t\t\tif task:\n\t\t\t\treturn task\n\t\t\telse:\n\t\t\t\treturn False\n\n\t\te... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Internal method to preview the contents of a model during model selection user would not call this normally | def _preview_model(self, model):
if model == "Return to task selection":
return
model_info = self.params["task"][self.task][model]
preview_output = f"""
{model}:\nInput shape (WxH): {model_info["model_width"]} x {model_info["model_height"]}\nDefault offline model (.om): {mode... | [
"def preview(record):\n pass",
"def begin_preview(self, output_dir: str):",
"def previewJVplot(self):\n self.selectionError.pack_forget() # deletes the error if it was previously displayed\n self.selectedItems = self.viewDataTree.selection()\n if len(self.selectedItems) != 1:\n... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Plot a correlation heatmap for the provided dataframe | def plot_correlation(df):
corr = df.corr()
mask = np.zeros_like(corr, dtype=np.bool)
mask[np.triu_indices_from(mask)] = True
f, ax = plt.subplots()
cmap = sns.diverging_palette(220, 10, as_cmap=True)
sns.heatmap(corr, mask=mask, cmap=cmap, vmax=.8, center=0,
square=True, linewidths=.5, cbar_kws={"shrink": .5... | [
"def plot_correlations(df, target, numeric_cols, cat_columns=None):\n if cat_columns:\n temp_df = df[numeric_cols + cat_columns + [target]]\n target_mean_encode(temp_df, cat_columns, target)\n\n else:\n temp_df = df[numeric_cols + [target]]\n\n fig, ax = plt.subplots(figsize=(12, 10))\... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
When the animal eats, it inceases the weight by amount. | def eat(self, amount):
self.__weight += amount | [
"def animal_weight_with_age(self):\n self.age += 1\n self.weight -= self.parameters['eta'] * self.weight",
"def animal_weight_with_food(self, food_eaten):\n self.weight += self.parameters['beta'] * food_eaten\n return self.weight",
"def calculate_weight(self):\n\n\t\tweight = 0\n\t\t... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Motion needs energy, therefore this function decreases the weight according to the constant self.__weightLossPerDistance. If self.__weight falls below 0 an error message is printed. | def move(self, distance):
self.__weight -= self._weightLossPerDistance*distance
if self.__weight<=0.0:
print "I'm starving..." | [
"def test_annual_weight_loss_decreases_weight(self):\n loc = (2,7)\n i = Island()\n a_sim = Herbivore(i, loc)\n initial_weight = a_sim.weight\n a_sim.annual_weight_loss()\n new_weight = a_sim.weight\n\n assert initial_weight > new_weight",
"def weight_loss(self):\n... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
This function checks if the argument 'fish' really is of type Fish and, if so, eats it. This accounts to deleting it from the dictionary 'animalDi'. Note that it is (as far as I know) not possible to globally erase the fish instance from memory. So deleting it from a "reservoir of animals" is the closest thing to killi... | def eat(self, fish, animalDi):
if isinstance(fish,Fish):
delvar=None
for a in animalDi:
if id(fish)==id(animalDi[a]):
delvar=a
break
if delvar!=None:
del animalDi[a]
print "Hmmm, that was ... | [
"def eat_fish(self, sim_turn, shark_coord, fish_coord):\n shark_eater = self._grid[shark_coord]\n fish_eaten = self._grid.pop(fish_coord)\n fish_eaten.alive = False\n\n self.move_animal(shark_coord, shark_eater, fish_coord)\n shark_eater.last_fed = sim_turn\n _logger.debug(... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Generates a special string if length is multiple of pi. If not provide 3 decimal places past floating point. | def _str_len(length):
if (length / pi).is_integer():
str_len = repr(int(length / pi)) + "pi"
else:
str_len = f"{length:.3f}".rstrip("0")
return str_len | [
"def fixed_pt_str(val, n):\r\n # (432,3) => 0.432 (3210,3) => 3.210 (23,1) => 2.3\r\n s = str(val)\r\n i = len(s)\r\n pfx = \"0.0000000\"\r\n return pfx[:n+2-i] + s if i <= n else s[:-n] + '.' + s[-n:]",
"def pi_nth_digit(n):\n return '%.*f' % (n,pi)",
"def pi_calculate(n):\n print(f\"%.... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Compute the perfect power of ``base`` greater than or equal to ``value``. | def next_power(value, base=2):
exponent = math.ceil(math.log(value, base))
return base**exponent | [
"def enclosing_power_of_two(value):\n return int(2**np.ceil(np.log2(value)))",
"def closest_power_2(x):\n Max_power = int((log(x-0.1,2)))\n return 2**Max_power",
"def convert_base(value, base):\n place = 1\n ret = []\n while (value > 0):\n next_place = place * base\n next_value = ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
r"""Equivalent to ``lx2``. Controls the order for the pressure field. | def order_pressure(self):
pn = self.order
staggered = self.params.oper.elem.staggered
problemtype_equation = self.params.nek.problemtype.equation.lower()
if "lin" in problemtype_equation and staggered is False:
logger.warning(
"Linear equation type and stag... | [
"def poly_pressure(self, channel=0, note=0x40, velocity=0x40):\n pass",
"def lP(q, i):\n lPoly = P.Polynomial([1])\n for j in range(len(q)):\n if j!=i:\n den = (q[i]-q[j]) # the denominator of lagrangian polynomials\n lPoly *= P.Polynomial([1/den, -q[i]/den])\n return ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Checks a chess vector of length 5 | def check_five(threats, board, vector, col, opp):
y_index, x_index, delta_y, delta_x = \
vector.y_index, vector.x_index, vector.delta_y, vector.delta_x
first_four = [(y_index + k * delta_y, x_index + k * delta_x) for k in range(4)]
free, rest = check_kernel(first_four, board, col, opp)
if not re... | [
"def check_six(threats, board, vector, col, opp):\n y_index, x_index, delta_y, delta_x = \\\n vector.y_index, vector.x_index, vector.delta_y, vector.delta_x\n first_four = [(y_index + k * delta_y, x_index + k * delta_x) for k in range(4)]\n free, rest = check_kernel(first_four, board, col, opp)\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Checks a chess vector of length 6 | def check_six(threats, board, vector, col, opp):
y_index, x_index, delta_y, delta_x = \
vector.y_index, vector.x_index, vector.delta_y, vector.delta_x
first_four = [(y_index + k * delta_y, x_index + k * delta_x) for k in range(4)]
free, rest = check_kernel(first_four, board, col, opp)
if not res... | [
"def correctBoard(board):\r\n if len(board) != 6:\r\n return False\r\n else:\r\n for i in board:\r\n if len(i) != 7:\r\n return False\r\n return True",
"def check_seven(threats, board, vector, col, opp):\n y_index, x_index, delta_y, delta_x = \\\n vector.... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Checks a chess vector of length 7 | def check_seven(threats, board, vector, col, opp):
y_index, x_index, delta_y, delta_x = \
vector.y_index, vector.x_index, vector.delta_y, vector.delta_x
second_four = [(y_index + k * delta_y, x_index + k * delta_x) for k in range(1, 4)]
free, rest = check_kernel(second_four, board, col, opp)
if ... | [
"def check_six(threats, board, vector, col, opp):\n y_index, x_index, delta_y, delta_x = \\\n vector.y_index, vector.x_index, vector.delta_y, vector.delta_x\n first_four = [(y_index + k * delta_y, x_index + k * delta_x) for k in range(4)]\n free, rest = check_kernel(first_four, board, col, opp)\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Carries out the epic 'Returned Solr Data', for the LibraryView GET end point This communicates with the external solr bigquery service. Any calls to the service are mocked in this test. | def test_returned_data_solr(self):
# Stub data
user_dave = UserShop()
stub_library = LibraryShop(want_bibcode=True)
# Librarian Dave makes a library with a few bibcodes
url = url_for('userview')
response = self.client.post(
url,
data=stub_library... | [
"def get_library(library_id, num_documents=0):\n\n config = get_config()\n\n start = 0\n rows = 25\n if num_documents>0:\n num_paginates = int(math.ceil(num_documents / (1.0*rows)))\n else:\n num_paginates=1\n\n documents = []\n r = requests.get(\n '{}/libraries/{id}?start=... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Runs n trials for a given model and stores state_dict checkpoints and statistics for each training runs. | def run_trials(trial_name, n, train_di, test_di, layers, drops, loss_func, opt_func): # UPDATE THIS TO JUST TAKE THE CLASSIFIER IN.
trial_dir = args.saved_models + '/{0}/'.format(trial_name)
if not os.path.exists(trial_dir):
os.makedirs(trial_dir)
metadata = "Parameters: \n classification_type={... | [
"def run(self, n_steps=1):\n # Extract key values (weights, state, slots) and update them in each loop.\n weights = self._model_in_training.weights\n state = self._model_in_training.state\n slots = self._task.optimizer.slots\n for step_i in range(1, n_steps + 1):\n self._step = step_i\n wei... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Collects the best model from each run in a given trial and stores them in 'best_models' subdirectory of that trial. | def get_trial_best_models(trial_name):
trial_dir = args.saved_models + '/{0}/'.format(trial_name)
run_dirs = [r[0] for r in os.walk(trial_dir)][1:]
best_models_dir = trial_dir+'best_models/'
if not os.path.exists(best_models_dir):
os.makedirs(best_models_dir)
for j, run_dir in enumerate(... | [
"def retrieve_best_model(self, metric):\n from utils.DatabaseHelper import insert_model_performance\n\n avg_val_accuracy_list = []\n for model in range(len(self.best_possible_models)):\n val_accuracy_list = self.best_possible_models[model][metric].values\n avg_accuracy = s... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Tests accuracy of ensembled predictions from the saved best models of a given trial. | def test_trial_ensemble(trial_name, classifier):
models_dir = args.saved_models + '/{0}/best_models/'.format(trial_name)
best_models = [m[2] for m in os.walk(models_dir)][0]
classifiers = []
for m in best_models:
new_classifier = classifier
new_classifier.load_checkpoint(models_dir+m)
... | [
"def check_accuracy_on_test():\n correct = 0\n total = 0\n model.eval()\n with torch.no_grad():\n for inputs, labels in testloader:\n inputs, labels = inputs.to(device), labels.to(device)\n outputs = model(inputs)\n _, predicted = torch.max(outputs.data, 1) #gets ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Test some obviously good and bad usernames. | def test_some_names(self, _, __, username, realname, success,):
try:
validate_username(username, realname)
except ValidationWarning as ex:
if success:
pytest.fail(
'Received unexpected error: {error}'.format(error=ex),
) | [
"def test_preprocess_username(self):\n validChars = \"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0987654321\"\n\n # TEST1\n for i in range(0, 256):\n before = chr(i)\n after, ok, errorMsg = Account.preprocessUsername(before)\n self.assertEqual(before in... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
accum(eventSet, values) Adds the counters of the indicated event set into the array values. The counters are zeroed and continue counting after the operation. | def accum(eventSet, values):
eventCount_p = ffi.new("int*", 0)
rcode = lib.PAPI_list_events(eventSet, ffi.NULL, eventCount_p)
if rcode < 0:
return rcode, None
eventCount = ffi.unpack(eventCount_p, 1)[0]
if len(values) != eventCount:
raise PapiInvalidValueError(message="the length ... | [
"def accumulate(self):\n self.accum_vals()",
"def aggregate(self, values):\n pass",
"def __accumulate_events__(trace_events, events):\n accumulated = {}\n for line in trace_events:\n event = line[1]\n if event in events:\n if event in accumulated:\n ac... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
add_event(eventSet, eventCode) Add single PAPI preset or native hardware event to an event set. | def add_event(eventSet, eventCode):
rcode = lib.PAPI_add_event(eventSet, eventCode)
if rcode > 0:
raise PapiError(message="Unable to add some of the given events: %i of"
" 1 event added to the event set" % rcode)
return rcode, None | [
"def add_events(eventSet, eventCodes):\n number = len(eventCodes)\n eventCodes_p = ffi.new(\"int[]\", eventCodes)\n rcode = lib.PAPI_add_events(eventSet, eventCodes_p, number)\n\n if rcode > 0:\n raise PapiError(message=\"Unable to add some of the given events: %i of\"\n \"... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
add_events(eventSet, eventCodes) Add list of PAPI preset or native hardware events to an event set. | def add_events(eventSet, eventCodes):
number = len(eventCodes)
eventCodes_p = ffi.new("int[]", eventCodes)
rcode = lib.PAPI_add_events(eventSet, eventCodes_p, number)
if rcode > 0:
raise PapiError(message="Unable to add some of the given events: %i of"
" %i events added ... | [
"def add_event(eventSet, eventCode):\n rcode = lib.PAPI_add_event(eventSet, eventCode)\n\n if rcode > 0:\n raise PapiError(message=\"Unable to add some of the given events: %i of\"\n \" 1 event added to the event set\" % rcode)\n\n return rcode, None",
"def add_events(self, ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
attach(eventSet, pid) Attach specified event set to a specific process or thread id. | def attach(eventSet, pid):
rcode = lib.PAPI_attach(eventSet, pid)
return rcode, None | [
"def attach(self, pid):\n self.dbg.attach(pid)\n self.dbg.debug_set_process_kill_on_exit(True)",
"def addProcess(self, pid, is_attached, parent=None, is_thread=False):\n if pid in self.dict:\n raise KeyError(\"The process %s is already registered!\" % pid)\n process = Ptrace... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
cleanup_eventset(eventSet) Remove all PAPI events from an event set and turns off profiling and overflow for all events in the EventSet. This can not be called if the EventSet is not stopped. | def cleanup_eventset(eventSet):
rcode = lib.PAPI_cleanup_eventset(eventSet)
return rcode, None | [
"def destroy_eventset(eventSet):\n eventSet_p = ffi.new(\"int*\", eventSet)\n rcode = lib.PAPI_destroy_eventset(eventSet_p)\n return rcode, None",
"def remove_events(eventSet, eventCodes):\n number = len(eventCodes)\n eventCodes_p = ffi.new(\"int[]\", eventCodes)\n rcode = lib.PAPI_remove_events... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
create_eventset() Create a new empty PAPI event set. The user may then add hardware events to | def create_eventset():
eventSet = ffi.new("int*", PAPI_NULL)
rcode = lib.PAPI_create_eventset(eventSet)
return rcode, ffi.unpack(eventSet, 1)[0] | [
"def create(self, event):\n raise NotImplementedError('create event is not implemented')",
"def createEvent(self):\n\n raise NotImplementedError( \"Should have implemented this\" )",
"def create_event_set_item(self, event_set_id, sampling_event_id,\n studies=None):\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
detach(eventSet) Detach specified event set from a previously specified process or thread id. | def detach(eventSet):
rcode = lib.PAPI_detach(eventSet)
return rcode, None | [
"def destroy_eventset(eventSet):\n eventSet_p = ffi.new(\"int*\", eventSet)\n rcode = lib.PAPI_destroy_eventset(eventSet_p)\n return rcode, None",
"def cleanup_eventset(eventSet):\n rcode = lib.PAPI_cleanup_eventset(eventSet)\n return rcode, None",
"def stop(eventSet):\n eventCount_p = ffi.new... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
destroy_eventset(eventSet) Deallocates memory associated with an empty PAPI event set. | def destroy_eventset(eventSet):
eventSet_p = ffi.new("int*", eventSet)
rcode = lib.PAPI_destroy_eventset(eventSet_p)
return rcode, None | [
"def cleanup_eventset(eventSet):\n rcode = lib.PAPI_cleanup_eventset(eventSet)\n return rcode, None",
"def detach(eventSet):\n rcode = lib.PAPI_detach(eventSet)\n return rcode, None",
"def destroy_set(target_set):\n _ipset('destroy', target_set)",
"def clear_events(self):\n\t\tself.events = []"... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
is_initialized() Return the initialized state of the PAPI library. | def is_initialized():
return lib.PAPI_is_initialized() | [
"def initialized(self) -> bool:",
"def initialized():\n return JobServer._initialized",
"def IsInitOnly(self) -> bool:",
"def is_loaded() -> bool:\n global _lib\n return _lib is not None",
"def is_initialized(self) -> bool:\n return Path(self.plan_dir).exists() and self.is_git_repository()",... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
library_init(version=pypapi.consts.PAPI_VER_CURRENT) Initialize the PAPI library. | def library_init(version=PAPI_VER_CURRENT):
rcode = lib.PAPI_library_init(version)
return rcode, None | [
"def _apiInitialize(self):\n # Specify the API that is being called\n self.api = 'https://api.spotify.com/'\n # Specify the Action that needs to be performed\n self.action = 'v1/search'\n self.actiontype = '&type=track'",
"def is_initialized():\n return lib.PAPI_is_initialize... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
list_events(eventSet) List the events that are members of an event set | def list_events(eventSet):
number = ffi.new("int*", 0)
rcode = lib.PAPI_list_events(eventSet, ffi.NULL, number)
if rcode < 0:
return rcode, None
eventCount = ffi.unpack(number, 1)[0]
events = ffi.new("int[]", eventCount)
rcode = lib.PAPI_list_events(eventSet, events, number)
ret... | [
"async def retrieve_beatmapset_events(self, beatmapset: Beatmapset) -> List[Event]:\n if beatmapset.id not in beatmapset_event_cache[self.db_name]:\n raw_event_generator = self.retrieve_events(\n where = \"beatmapset_id=%s\",\n where_values = (beatmapset.id,),\... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
read(eventSet) Copies the counters of the indicated event set into the provided array. The counters continue counting after the read and are not reseted. | def read(eventSet):
eventCount_p = ffi.new("int*", 0)
rcode = lib.PAPI_list_events(eventSet, ffi.NULL, eventCount_p)
if rcode < 0:
return rcode, None
eventCount = ffi.unpack(eventCount_p, 1)[0]
values = ffi.new("long long[]", eventCount)
rcode = lib.PAPI_read(eventSet, values)
re... | [
"def accum(eventSet, values):\n eventCount_p = ffi.new(\"int*\", 0)\n rcode = lib.PAPI_list_events(eventSet, ffi.NULL, eventCount_p)\n\n if rcode < 0:\n return rcode, None\n\n eventCount = ffi.unpack(eventCount_p, 1)[0]\n\n if len(values) != eventCount:\n raise PapiInvalidValueError(mes... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
remove_event(eventSet, eventCode) Remove a hardware event from a PAPI event set. | def remove_event(eventSet, eventCode):
rcode = lib.PAPI_remove_event(eventSet, eventCode)
return rcode, None | [
"def remove_events(eventSet, eventCodes):\n number = len(eventCodes)\n eventCodes_p = ffi.new(\"int[]\", eventCodes)\n rcode = lib.PAPI_remove_events(eventSet, eventCodes_p, number)\n\n if rcode > 0:\n raise PapiError(message=\"Unable to remove some of the given events: \"\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
remove_events(eventSet, eventCodes) Remove an list of hardware events from a PAPI event set. | def remove_events(eventSet, eventCodes):
number = len(eventCodes)
eventCodes_p = ffi.new("int[]", eventCodes)
rcode = lib.PAPI_remove_events(eventSet, eventCodes_p, number)
if rcode > 0:
raise PapiError(message="Unable to remove some of the given events: "
"%i of %i even... | [
"def remove_events(self, events):\n\n raise NotImplementedError # pragma: no cover",
"def remove_event(eventSet, eventCode):\n rcode = lib.PAPI_remove_event(eventSet, eventCode)\n return rcode, None",
"def destroy_eventset(eventSet):\n eventSet_p = ffi.new(\"int*\", eventSet)\n rcode = lib.P... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
start(eventSet) Starts counting all of the hardware events contained in the EventSet. All counters are implicitly set to zero before counting. | def start(eventSet):
rcode = lib.PAPI_start(eventSet)
return rcode, None | [
"def startTest(self, event):\r\n self.numtests += 1\r\n self._start = event.startTime",
"def run (self) :\n \n threads = []\n concurrency = int(self.bench_cfg['concurrency'])\n \n self._start ()\n \n for tid in range (0, concurrency) :\n \n self... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
state(eventSet) Returns the counting state of the specified event set. | def state(eventSet):
status = ffi.new("int*", 0)
rcode = lib.PAPI_state(eventSet, status)
return rcode, ffi.unpack(status, 1)[0] | [
"def getNumStates(self) -> \"int\":\n return _coin.ScXMLStateElt_getNumStates(self)",
"def getNumStates(self) -> \"int\":\n return _coin.ScXMLScxmlElt_getNumStates(self)",
"def state(self):\n return self._state.value",
"def getNumStates(self) -> \"int\":\n return _coin.ScXMLParalle... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
stop(eventSet) Stop counting hardware events in an event set and return current values. | def stop(eventSet):
eventCount_p = ffi.new("int*", 0)
rcode = lib.PAPI_list_events(eventSet, ffi.NULL, eventCount_p)
if rcode < 0:
return rcode, None
eventCount = ffi.unpack(eventCount_p, 1)[0]
values = ffi.new("long long[]", eventCount)
rcode = lib.PAPI_stop(eventSet, values)
re... | [
"def stop(self, stopAll = False):\n try:\n dbg.prn(dbg.BKP,\"stop-->\")\n hid = self.current\n if (hid and (hid in self.events)):#there is an event being copied right now (or just finished)\n priority = self.events[hid].priority #get its priority (to remove lat... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Redirect to the login page when LoginError is raised. | def handle_login_error(e):
flash("You do not have access rights.")
return redirect(url_for('auth.login')) | [
"def redirect_after_login(request):\n url_path = request.GET.get(\"next\", None) \n if url_path is None:\n return redirect(settings.LOGIN_REDIRECT_URL)\n elif not is_safe_url(\n url=resolve_url(url_path),\n allowed_hosts={request.get_host()},\n require_https=request.... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Parses sitetree_children tag parameters. | def sitetree_children(parser: Parser, token: Token) -> 'sitetree_childrenNode':
tokens = token.split_contents()
use_template = detect_clause(parser, 'template', tokens)
tokens_num = len(tokens)
clauses_in_places = (
tokens_num == 5 and tokens[1] == 'of' and tokens[3] == 'for' and tokens[4] in (... | [
"def _parse_children(self):\n\n return True",
"def _parse_children(self):\n for child in self.xml:\n if child.tag == \"input\":\n self.inputs.append(TestInput(child, self))\n elif child.tag == \"output\":\n outvar = TestOutput(child)\n s... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Parses sitetree_breadcrumbs tag parameters. | def sitetree_breadcrumbs(parser: Parser, token: Token) -> 'sitetree_breadcrumbsNode':
tokens = token.split_contents()
use_template = detect_clause(parser, 'template', tokens)
tokens_num = len(tokens)
if tokens_num == 3:
tree_alias = parser.compile_filter(tokens[2])
return sitetree_bread... | [
"def make_breadcrumbs(path):\n DELIMITER = '/'\n breadcrumbs = []\n breadcrumbs.append({'title': 'Top', 'path': '', 'current': False})\n splitPath = path.split(DELIMITER)\n for i, crumb in enumerate(splitPath):\n breadcrumbs.append({'title': crumb,\n 'path': DELIMITE... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Parses sitetree_menu tag parameters. {% sitetree_menu from "mytree" include "trunk,1,level3" %} Used to render trunk, branch with id 1 and branch aliased 'level3' elements from "mytree" site tree as a menu. | def sitetree_menu(parser: Parser, token: Token) -> 'sitetree_menuNode':
tokens = token.split_contents()
use_template = detect_clause(parser, 'template', tokens)
tokens_num = len(tokens)
if tokens_num == 5 and tokens[3] == 'include':
tree_alias = parser.compile_filter(tokens[2])
tree_bra... | [
"def menus(context, kind='header', menu_type='dropdown'):\n t = get_template(\"menu/tags/%s.html\" % menu_type)\n\n footer = (kind == 'footer')\n menus = Menu.objects.filter(active=True, footer=footer)\n\n # path = context['request'].path\n # highlighted = any([path.startswith(e.destination) for e in... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
This tag is much the same as Django builtin 'url' tag. The difference is that after 'for' it should get TreeItem object. | def sitetree_url(parser: Parser, token: Token) -> 'sitetree_urlNode':
return sitetree_urlNode.for_tag(parser, token, 'for', 'sitetree_url for someitem') | [
"def item_url(self):\n return self.get_url(item=True)",
"def URLTag(parentComponent, componentName=None, domletProperty=None, **kw):\n\n kw['domletProperty'] = domletProperty\n prop = (domletProperty or '').split('.')\n\n if len(prop)==1 or prop[-1]=='text':\n return URLText(parentComponent... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Helper function detects a certain clause in tag tokens list. Returns its value. | def detect_clause(parser: Parser, clause_name: str, tokens: List[str]):
if clause_name in tokens:
t_index = tokens.index(clause_name)
clause_value = parser.compile_filter(tokens[t_index + 1])
del tokens[t_index:t_index + 2]
else:
clause_value = None
return clause_value | [
"def clause_is_present(clause, search):\n\n for elem in surface_selectables(search):\n if clause == elem: # use == here so that Annotated's compare\n return True\n else:\n return False",
"def FirstWordOfClause(sentence, word):\n if word.token in string.punctuation or word.pos in... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Render helper is used by template node functions to render given template with given tree items in context. | def render(context: Context, tree_items: List['TreeItemBase'], use_template: TypeStrExpr):
context.push()
context['sitetree_items'] = tree_items
if isinstance(use_template, FilterExpression):
use_template = use_template.resolve(context)
content = get_template(use_template).render(context.flatt... | [
"def tree_render(request, upy_context, vars_dictionary):\n page = upy_context['PAGE']\n return render_to_response(page.template.file_name, vars_dictionary, context_instance=RequestContext(request))",
"def render(self, context):\n with self.managed_custom_context(context) as new_context:\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Returns the root node of the document if available | def root(self) -> Optional["HOCRNode"]:
return self.html.getroottree().getroot() | [
"def get_root_node(self):\n\n return self.dom.documentElement",
"def getRoot(self):\n\n return self.root_node",
"def get_root(self):\n return self.xml_tree",
"def get_root(self):\r\n if len(self.nodes) == 0:\r\n root = self.empty_sparse[self.levels]\r\n retu... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Returns the body node of the document if available | def body(self) -> Optional["HOCRNode"]:
return self.html.find("body") | [
"def _root_body_(self):\n node = self.worldbody.find(\"./body[@name='{}']\".format(self._root_))\n return node",
"def getBody(self):\n return self.body",
"def nxmlHasBody(inData):\n #xml = codecs.open(nxmlName, encoding=\"utf8\").read()\n try:\n root = etreeFromXml(inData)\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Searches for the ocrsystem meta tag and returns its content. | def ocr_system(self) -> Optional[str]:
try:
meta = self.html.cssselect("meta[name='ocr-system']")[0]
return meta.get("content")
except IndexError:
warnings.warn("Missing ocr-system", MissingRequiredMetaField)
return None | [
"def meta_content(doc, meta_name):\n meta = doc.cssselect(meta_name)\n content = None\n if meta is not None and len(meta) > 0:\n content = meta[0].attrib.get('content')\n if content:\n return content.strip()\n return ''",
"def get_system_metadata(self, object_id, sys_tags = None):\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Returns the max BBox containing all other BBoxes of tree nodes Iterates over the tree, collecting all BBoxes and calls BBox.max_bbox with the list of BBoxes as argument. | def bbox(self) -> Optional[BBox]:
boxes = []
for node in self.iter():
box = node.bbox
if box:
boxes.append(box)
return BBox.max_bbox(boxes) | [
"def get_max_node(self) -> BSTNode[T]:\n \n return self.tree_maximum(self.root)\n ...",
"def find_max(self)->(any, any):\n #---- to do ----\n # complete this method by calling bst.find_max()\n # return the key and the value associated with the largest key in the tree \n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Displays graph of Iteration vs Errors and Epoch vs MSE. | def display_graph(self, save_graph = True):
fig, axs = plt.subplots(2, figsize = (5,8))
fig.suptitle("Graph to show changes in errors with iterations or epoch")
axs[0].plot(self.total_number_of_iteration[:-1], self.collection_of_errors[:-1])
axs[0].set(xlabel ="Total Number of iterat... | [
"def displayEpochs(self, errorEpochs, savePath = '.'):\n plt.plot(errorEpochs)\n plt.ylabel('error (%)')\n plt.xlabel('epoch')\n plt.xticks(range(len(errorEpochs)))\n plt.title('Training Error by Epoch')\n plt.savefig(f'{savePath}/errorEpochs.png')\n plt.show(block=F... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Returns the system (linux, darwin, windows). | def system():
import platform
return platform.system().lower() | [
"def determine_os(self):\n system_type=\"\"\n try: #Linux check\n release_file = file(\"/etc/os-release\")\n for line in release_file:\n if re.search(\"^NAME\", line):\n system = line.split(\"=\")[-1]\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Returns the architecture of the python interpreter, used for default compilation architecture | def architecture():
import platform
return platform.architecture()[0][:-3] | [
"def get_package_architecture(self):\n res = self.cli(command=\"show version detail\").response()\n if res:\n search = re.search(r'(64-bit Kernel|Kernel\\s+64-bit)', res, re.I)\n arch = '64' if search else '32'\n self.log(level='INFO', message=\"Kernel architecture: %s... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
constrain to prevent general ledger account from being repeated in different budget position | def check_account_unique(self):
for rec in self:
result = False
for account in rec.account_ids:
self.env.cr.execute("""
SELECT COUNT(account_id)
FROM account_budget_rel
... | [
"def create_budget_confirmation_invoice(self):\n confirmation_pool = self.env['account.budget.confirmation']\n currency_pool = self.env['res.currency']\n new_confirm_id = False\n flag = False\n for invoice in self:\n # v9: if invoice.invoice_type in ('purchase','sale')... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Measures the direction of the landmark with respect to robot. Add noise | def sense_direction(robot_pos, landmark, noise):
direction = cal_direction(robot_pos, (landmark[0], landmark[1]))
angle_noise = gauss_noise(0, noise*math.pi/180)
if direction + angle_noise > math.pi:
result = direction + angle_noise - 2*math.pi
elif direction + angle_noise < - math.pi:
r... | [
"def _set_random_direction(self):\n direction = np.random.randn(self.polytope.dim)\n self.direction = direction / norm(direction)",
"def showLandMarkData(self):\r\n print(\"disX = \", self.disX)\r\n print(\"disY = \", self.disY)\r\n print(\"dis = \", self.dist)\r\n print(... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
rcpath = util.get_parent_rcpath(sdata.getRcPath()) log('setting rcpath= %s' % (rcpath)) xml_output = yang.Sdk.getData(rcpath, '', sdata.getTaskId()) obj = util.parseXmlString(xml_output) return obj | def getParentObject(sdata):
rcpath = util.get_parent_rcpath(sdata.getRcPath())
#log('setting rcpath= %s' % (rcpath))
key = 'parent.%s' % (rcpath)
obj = sdata.getSessionItem(key)
if obj != None:
log('getParentObject:cache-hit key=%s' % (key))
return obj
#log('getParentObject:ca... | [
"def xml_path():\n return get_root(fixed_path=OLD_TRAN_FOLDER)",
"def read_model_data_ancestor(cfg, variable_group) -> tuple:\n filepath = io.get_ancestor_file(cfg, 'MODELS_' + variable_group + '.nc')\n ancestor_ds = xr.open_dataset(filepath)\n\n anc_da = ancestor_ds[variable_group].load()\n anc_da... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
This method loads the weighted edgelist into a dataframe. | def prepare_data(self):
# Load data
weighted_edgelist_df = pd.read_csv(self.weighted_edgelist)
return weighted_edgelist_df | [
"def _edge_list_to_dataframe(ls, src_column_name, dst_column_name):\n assert HAS_PANDAS, 'Cannot use dataframe because Pandas is not available or version is too low.'\n cols = reduce(set.union, (set(e.attr.keys()) for e in ls))\n df = pd.DataFrame({\n src_column_name: [e.src_vid for e in ls],\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
This method calculates centrality measures, i.e. degree centrality, betweenness centrality, and eigenvector centrality, for each node and saves the results as a CSVfile in the output directory. | def calculate_centrality_measures(self, network_graph, cutoff_edgeweight):
# Calculate degree centrality
degree_centrality = nx.degree_centrality(network_graph)
# Create dataframe for degree centrality
degree_df = pd.DataFrame(degree_centrality.items(),
... | [
"def get_centrality_measures(network, tol):\n degree = []\n betweenness = []\n closeness = []\n eigenvector_centrality = []\n kshell = []\n degree_dic = nx.degree_centrality(network)\n betweenness_dic = nx.betweenness_centrality(network)\n closeness_dic = nx.closeness_centrality(network)\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Hook into giphypop to find a gif. If no search term, just return a random gif. If a search term is given, try to translate it and default back to a search | def gifme(self, search=None):
try:
return self.api.random_gif(search).media_url
except GiphyApiException:
try:
return self.api.translate(search).media_url
except GiphyApiException:
try:
return self.api.search_list(se... | [
"def gif(search, unsafe=False):\n searchb = quote(search.encode(\"utf8\"))\n\n safe = \"&safe=\" if unsafe else \"&safe=active\"\n searchurl = \"https://www.google.com/search?tbs=itp:animated&tbm=isch&q={0}{1}\".format(\n searchb, safe\n )\n\n # this is an old iphone user agent. Seems to make ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Example of using waypoints and heading to make the car in the right direction | def stay_within_heading(params):
import math
# Read input variables
waypoints = params['waypoints']
closest_waypoints = params['closest_waypoints']
heading = params['heading']
# Initialize the reward with typical value
reward = 1.0
# Calculate the direction of the center line based o... | [
"def hMotion(robot):\n # conversion to degrees makes the following easier to read\n direction=int(math.degrees(robot.getDirection())) %360\n\n if 90 <= direction <= 270: return LEFT\n\n # there is discontinuous range heading right\n if 90 >= direction >= 0: return RIGHT\n if 360>= direction... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Shape for the active observation based on observation_keys. | def active_observation_shape(self):
if not isinstance(self._env.observation_space, spaces.Dict):
return super(GymAdapter, self).active_observation_shape
observation_keys = (
self.observation_keys
or list(self._env.observation_space.spaces.keys()))
ac... | [
"def observation_shape(self):\n return self.data[0].shape",
"def state_shape(self):\n pass",
"def _flat_shape(observation):\n return np.sum(int(np.prod(v.shape)) for k, v in observation.items())",
"def get_shape_keys (self, obj):\n if obj.data.shape_keys is None:\n return []\n else... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
In order to be backwards compatible, HOME/.graphql/token if it exists, is copied to HOME/.stage_check/graphql/token. | def _init_token_path(self):
old_token_path = os.path.join(self.user_home_path, ".graphql")
old_token_file = os.path.join(old_token_path, "token")
self.__gql_path = os.path.join(self.base_path, "graphql")
if not os.path.exists(self.gql_path):
os.mkdir(self.gql_path)
new_token_file... | [
"def import_token():\n try:\n import auth\n return auth.DISCORD_HACKSPACE_TOKEN\n except ImportError:\n try:\n import os\n return os.environ[\"DISCORD_HACKSPACE_TOKEN\"]\n except KeyError:\n print(\"\"\"\nERROR: DISCORD_HACKSPACE_TOKEN neither provi... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Treat variable as a scalar if it is a float or an int. | def is_scalar(variable):
return isinstance(variable, float) or isinstance(variable, int) | [
"def is_scalarlike(item):\n try:\n float(item)\n return True\n except TypeError:\n return False",
"def is_scalar(obj):\n return not isinstance(obj, bool) and isinstance(obj, (int, float, complex))",
"def coerce_scalar_field(self, value):\n if not isinstance(value, Field):\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
return a random n by n symmetric matrix | def random_symmetric_matrix(n):
M = randn(n, n)
return 0.5*(M + M.T) | [
"def random_matrix(m, n):\n matrix = [[random.randint(-10, 10) for column in range(n)] for row in range(m)]\n return matrix",
"def randmatrix(self, m, n):\n return [[random.randint(-9, 9) for j in range(n)] for i in range(m)]",
"def random_orthogonal_matrix(n):\n a = np.random.randn(n, n)\n U, _,... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Generate N random m by n nonsingular matrices. | def random_nonsingular_matrices(m, n, N=1):
k = 0
matrix = randn(m, n)
while min(svd(matrix)[1]) < 0.1:
matrix = randn(m, n)
matrices = [matrix]
while k < N:
while equal(matrix, matrices[-1]) or min(svd(matrix)[1]) < 0.1:
# make sure matrix is not close to singular and on... | [
"def random_matrix(m, n):\n matrix = [[random.randint(-10, 10) for column in range(n)] for row in range(m)]\n return matrix",
"def random_orthogonal_matrix(n):\n a = np.random.randn(n, n)\n U, _, _ = linalg.svd(a)\n assert U.shape == (n, n)\n return U",
"def randmatrix(self, m, n):\n return... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Generate a random m by n nonsingular matrix. | def random_nonsingular_matrix(m, n):
return random_nonsingular_matrices(m, n, 1) | [
"def random_nonsingular_matrices(m, n, N=1):\n k = 0\n matrix = randn(m, n)\n while min(svd(matrix)[1]) < 0.1:\n matrix = randn(m, n)\n matrices = [matrix]\n while k < N:\n while equal(matrix, matrices[-1]) or min(svd(matrix)[1]) < 0.1:\n # make sure matrix is not close to si... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Generate a random CLOSED LOOP state transition matrix that has no eigenvalues greater than 1. | def random_stable_state_transition_matrix(n):
A = randn(n,n)
while min(svd(A)[1]) < 0.1:
A = randn(n,n)
eigenvalues, eigenvectors = eig(A)
# if any eigenvalues have positive real parts, multiply them by -1
signs = 2*((real(eigenvalues) <= 0).astype(int) - 0.5)
new_eigenvalues = signs * e... | [
"def rand_init_state(self):\n state = np.random.random((self.lattice, self.lattice))\n state[state >= 0.5] = 1\n state[state < 0.5] = -1\n return state",
"def sgm_generate(len, tr):\n\n seq = np.zeros(len)\n\n # tr must be 2x2 matrix\n tr = np.asarray(tr) # make sure seq is n... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Generate a random system for the optimal control algorithm implemented in Todorov's kalman_lqg.m MATLAB code. | def random_kalman_lqg_system():
N = 100 # duration in number of time steps
# number of state variables
nx = randint(2,5)
# number of control inputs
nu = randint(2,5)
# number of observable outputs
ny = randint(2,5)
# number of additive process noise variables
np = ra... | [
"def random_time_varying_kalman_lqg_system():\n N = 100 # duration in number of time steps\n \n # number of state variables\n nx = randint(2,5)\n\n # number of control inputs\n nu = randint(2,5)\n\n # number of observable outputs\n ny = randint(2,5)\n\n # number of additive proce... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Generate a random timevarying system for the optimal control algorithm implemented in Todorov's kalman_lqg.m MATLAB code. | def random_time_varying_kalman_lqg_system():
N = 100 # duration in number of time steps
# number of state variables
nx = randint(2,5)
# number of control inputs
nu = randint(2,5)
# number of observable outputs
ny = randint(2,5)
# number of additive process noise variable... | [
"def random_kalman_lqg_system():\n N = 100 # duration in number of time steps\n \n # number of state variables\n nx = randint(2,5)\n\n # number of control inputs\n nu = randint(2,5)\n\n # number of observable outputs\n ny = randint(2,5)\n\n # number of additive process noise vari... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Perturb the given matrix trajectory with Gaussian noise scaled by scale. | def perturb(matrix_trajectory, scale):
perturbed_trajectory = matrix_trajectory.flatten()
for i in range(len(perturbed_trajectory)):
perturbed_trajectory[i] += scale*randn()
return perturbed_trajectory.reshape(matrix_trajectory.shape) | [
"def gaussian_conv_matrix(t_in, t_out, sigma):\n # sigma = fwhm / 2.355\n ksi = (t_in[None, :] - t_out[:, None]) / sigma\n bla = np.exp( -0.5 * ksi**2)\n bla = bla / np.sum(bla, axis=1)[:, None] # normalize sum\n return bla",
"def gaussian_perturb(self,arr, std):\n\n\n # noise = self.theano_r... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
5/27/2016 James Bridgewater Creating this function as a regression test to compare results from kalman_lqg.py to results from kalman_lqg.m. | def test_kalman_lqg():
# test paramters
tolerance = 1e-5 # 10 parts per million
# Load the saved test cases
with open("kalman_lqg_test_cases.pkl", 'r') as file_handle:
test_cases = pickle.load(file_handle)
test_counter = 0
for test_case in test_cases:
test_counter = test_counte... | [
"def test_time_varying_kalman_lqg():\n # test paramters\n tolerance = 1e-9 # 1 part per billion\n\n # Load the saved test cases\n with open(\"time_varying_test_cases.pkl\", 'r') as file_handle:\n test_cases = pickle.load(file_handle)\n test_counter = 0\n for test_case in test_cases:\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
6/17/2016 James Bridgewater Creating this function as a regression test to compare results from kalman_lqg.py to results it produced previously that I believe to be optimal because they passed perturbation testing. | def test_time_varying_kalman_lqg():
# test paramters
tolerance = 1e-9 # 1 part per billion
# Load the saved test cases
with open("time_varying_test_cases.pkl", 'r') as file_handle:
test_cases = pickle.load(file_handle)
test_counter = 0
for test_case in test_cases:
test_counter ... | [
"def test_kalman_lqg():\n # test paramters\n tolerance = 1e-5 # 10 parts per million\n\n # Load the saved test cases\n with open(\"kalman_lqg_test_cases.pkl\", 'r') as file_handle:\n test_cases = pickle.load(file_handle)\n test_counter = 0\n for test_case in test_cases:\n test_count... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
1. calculate number of spaces in the first pass 2. calculate the new length of the string 3. replace each space with %20 in second pass | def replace_space(s):
s = list(s)
space_count = 0
old_index = len(s)-1
for char in s:
if char == ' ':
space_count += 1
#print space_count
pad = [' ']*(space_count*2)
s += pad
new_index = len(s)-1
while old_index >= 0:
if s[old_index] == ' ':
... | [
"def replace_spaces(string):\r\n final_string = \"\"\r\n for character in string:\r\n if character == \" \":\r\n final_string += \"%20\"\r\n else:\r\n final_string += character\r\n print(final_string)\r\n return final_string",
"def URLify(string_list, length):\n\tsp... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Queries the metadata keys (column names) that are currently configured | def get_metadata_keys(dbsession):
return [datum for datum in dbsession.query(MetaDatum).order_by(MetaDatum.order).all() ] | [
"def metadataTableBasicKeys():\n return [\"Title\", \"Authors\", \"Description\", \"PubMed ID\", \"Contact Name\", \"Contact Email\", \"Release Date\", \"dataType\", \"Platform\"]",
"def get_key_columns(self, cursor, table_name):\n source_field_dict = self._name_to_index(cursor, table_name)\n\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Queries all metadata sets that are pending for the currently logged in user | def query_pending_annotated(dbsession, user):
return dbsession.query(MetaDataSet).filter(and_(
MetaDataSet.user==user,
MetaDataSet.group==user.group,
MetaDataSet.submission==None)
).all() | [
"def filter_granted(self, queryset):\n return Dataset.filter_by_user(self.request.user)",
"def get_querysets(self):\n return super(ActiveUsersManager, self).get_querysets().filter(user__is_active__=True)",
"def query_all_objects( self ):\n return self._k8s.query_daemonsets( filter=self._fil... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Creates a data frame from a list of MetaDataSets | def dataframe_from_mdsets(mdsets):
return pd.DataFrame(
[
{
mdrec.metadatum.name : str(mdrec.value) for mdrec in mdset.metadatumrecords
}
for mdset in mdsets
]
) | [
"def _make_data_frame(list):\n\n if len(list) == 0:\n data_frame = pd.DataFrame()\n else:\n observation_fields = list[0].__dict__.keys()\n data_frame = pd.DataFrame(columns=observation_fields)\n\n i = 0\n for l in list:\n observation_values = l.__dict__.values()\n... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Converts a series of dates to ISO format strings. The dates can either be provided as datetime objects or will otherwise be casted to `str` and parsed using the provided datetime format string. | def string_conversion_dates(series, datetimefmt):
if pdtypes.is_datetime64_dtype(series):
return series.map(lambda x : x.isoformat())
return series.map(lambda x : strptime_iso_or_empty(x, datetimefmt)) | [
"def convertDateToISO(date):\n if re.search(\"^[0-9]{2}/[0-9]{2}/[0-9]{4}$\", date):\n date = date[6:10] + \"-\" + date[3:5] + \"-\" + date[0:2]\n else:\n raise ValueError(\"Incorrect date format\")\n return date",
"def test_to_iso_format(self):\n test_string = TestDatetimeTools.isof... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Import a sample sheet into the database. Extracts the metadata from the sample sheet, handles date and time conversions if necessary and adds the metadata to the database. The metadata will be pending, i.e. not associated with a submission. | def import_samplesheet(dbsession, file_like_obj, user):
# Try to read the sample sheet
try:
data = pd.read_excel(file_like_obj)
except Exception as e:
raise SampleSheetReadError(f"{e}")
# Query column names that we expect to see in the sample sheet (intra-submission duplicates)
meta... | [
"def load_sheet(self):\n if self.flags.sheet_name:\n logger.info(timed_message(f\"Importing: {self.flags.sheet_name}\"))\n logger.debug(f\"Importing data from: {self.config.sheet_config['sheet_key']}\")\n else:\n logger.info(\n timed_message(f\"Importing... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
save_related_job_templates loops through all of the job templates that use an Inventory that have had their Organization updated. This triggers the rebuilding of the RBAC hierarchy and ensures the proper access restrictions. | def save_related_job_templates(sender, instance, **kwargs):
if sender is not Inventory:
raise ValueError('This signal callback is only intended for use with Project or Inventory')
update_fields = kwargs.get('update_fields', None)
if (update_fields and not ('organization' in update_fields or 'organi... | [
"def ensure_job_templates_for_project(\n self,\n connection,\n project_spec,\n project,\n credentials\n ):\n self.stdout.write(f\"Creating or updating job templates for '{project.name}'\")\n if 'PLAYBOOKS' in project_spec:\n playbooks = project_spec['PL... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Context manager to disable capturing activity stream changes. | def disable_activity_stream():
try:
previous_value = activity_stream_enabled.enabled
activity_stream_enabled.enabled = False
yield
finally:
activity_stream_enabled.enabled = previous_value | [
"def suppress_screen_change(self):\n self.suppressed = True",
"def disable():\n ActionLogger.disable()",
"def disable_error_and_warning_recording(self):\n self._disable_err_warn_rec = True",
"def disable_feedback(self) -> None:\n self._feedback_handler = None\n for ses in self._... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Provider a signal handler to return the current user from the current request when using Django REST Framework. Requires that the APIView set drf_request on the underlying Django Request object. | def get_current_user_from_drf_request(sender, **kwargs):
request = get_current_request()
drf_request_user = getattr(request, 'drf_request_user', False)
return (drf_request_user, 0) | [
"def handle_user_request(self, request):\n raise NotImplementedError",
"def current_user(self, request=None) -> TypeVar('User'):\n h = self.authorization_header(request)\n h = self.extract_base64_authorization_header(h)\n h = self.decode_base64_authorization_header(h)\n user = s... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Return the first object in hierarchy that contains the given name | def GetObjectWithName(name):
nodeList = getAllNodes()
for n in nodeList:
if name in n.Name:
return n
return None | [
"def get(scene, name):\n for fbx_object in get_all(scene):\n if fbx_object.GetName() == name:\n return fbx_object\n\n return None",
"def findNodeFromName(self, name):\n path = name.split('|')\n for root in self.roots:\n if root.name==path[0]:\n newNa... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
return given layer and their children | def get_layer_children(root, result):
# print root.name
num_children = root.getNumChildren()
if num_children == 0:
result.append(root)
else:
for i in range(1, num_children + 1):
child = root.getChild(i)
# print "step" + str(i) + " " + child.name
... | [
"def sublayers(self):\n return self._sublayers",
"def get_pair_children(self):",
"def findLayerSelection():\n\n curGeo = mari.geo.current()\n curChannel = curGeo.currentChannel()\n channels = curGeo.channelList()\n curLayer = mari.current.layer()\n\n layers = ()\n layerList = ()\n select... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
return first layer with the given prefix in name | def get_layer_by_prefix(prefix):
num_layers = MaxPlus.LayerManager.GetNumLayers()
for i in range(num_layers):
lyr = MaxPlus.LayerManager.GetLayer(i)
name = lyr.GetName()
if prefix in name:
return lyr | [
"def _get_layer(self, name: str) -> layer.Layer:\n self._validate_layer_name(name)\n return self.layers[name]",
"def get(self, name):\n if not name:\n raise ValueError(\"Layer name is required\")\n\n for layer in self._layers:\n if layer.name == name:\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
tcb controller make some strange stuff adding unused key, this method remove the key if it has been added on all controllers,pos rot,scale and you want to clean up | def remove_unused_key(source, target):
src_transform = GetTransformControl(source)
src_pos_controller = src_transform.GetPositionController()
src_rot_controller = src_transform.GetRotationController()
src_scale_controller = src_transform.GetScaleController()
src_controller_list = [src_pos_contr... | [
"def _wipe_key(self):\n\t\ttry:\n\t\t\tdel self.aes_key\n\t\texcept AttributeError:\n\t\t\tpass",
"def _wipe_key(self):\n\n try:\n del self.aes_key\n except AttributeError as exc:\n pass",
"def keyReleased():\n lowerKey = str(key).lower()\n if lowerKey == 'w':\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
create a new runbook file | def new(title):
filename = create_new_runbook(title)
print(f"\ncreated new runbook '{filename}'\n") | [
"def create_file():\n seeder_file_path = f\"{BASE_PATH}/{underscore(CreateSeeder.name)}.py\"\n seeder_file = open(seeder_file_path,\"w+\")\n seeder_file.write(\n Template(filename='./migrations/seeder.py.mako') \\\n .render(\n seeder_name=CreateSeede... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
return manhattan distance between two lists | def manhattan_distance(x, y):
return sum(abs(a - b) for a, b in zip(x, y)) | [
"def manhattanDistance(loc1, loc2):\n # BEGIN_YOUR_ANSWER (our solution is 1 lines of code, but don't worry if you deviate from this)\n return sum(abs(comp1 - comp2) for comp1, comp2 in zip(loc1, loc2))\n # END_YOUR_ANSWER",
"def manhattan_distance(start, end):\n return sum(abs(e - s) for s, e in zip(... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
returns the n_root of an value | def nth_root(value, n_root):
root_value = 1 / float(n_root)
return round(Decimal(value) ** Decimal(root_value), 3) | [
"def my_root(a, n=2):\n res = a**(1.0/n)\n return res",
"def root_method(N):\n a = math.floor(factoring_support.intsqrt(N)) + 1\n while True:\n b = factoring_support.intsqrt(a**2 - N)\n if is_integer(b):\n return a - b\n a += 1",
"def uglyRoot(n):\n x = 1.0 \n x = x - (x * x - n) ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
takes in two vectors and returns a tuple of the vectors with both non zero dimensions i.e. | def common_dimensions(v1, v2):
list1, list2 = [], []
for i in range(0, len(v1)):
if v1[i] != 0 and v2[i] != 0:
list1.append(v1[i])
list2.append(v2[i])
# print 'INDEX SAME:',i
return list1, list2 | [
"def cartesian( v1, v2 ):\n return tuple([(x,y) for x in v1 for y in v2])",
"def get_vector(a, b):\n return Vector(b.x - a.x, b.y - a.y, b.z - a.z)",
"def vector2d_from_lists(x, y):\n n = len(x)\n if len(y) == n:\n vecs = [Vector2D(x[i], y[i]) for i in range(n)]\n return vecs",
"def ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
takes in a list an returns the amount of non zero values in the list i.e. list [0 0 0 0 1 2 3 ] > returns 3 | def nonzero_count(my_list):
counter = 0
for value in my_list:
if value != 0:
counter += 1
return counter | [
"def number_of_negatives(L):\n count = 0\n for l in L:\n if l < 0:\n count += 1\n \n return count",
"def number_of_values(my_list):\n return len(my_list)",
"def get_num_zeros(self):\n return self.get_num_values(0)",
"def num_empty(state):\n return sum([row.co... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
case amplifies value basically taking an exponential to a constant 2.5 | def custom_case_amplification(value):
bool_negative = False
if value < 0:
bool_negative = True
result = abs(value) ** 2.5
if bool_negative:
result *= -1
return result | [
"def AlbiniExponentA(self) :\n self.exponentA = 133. * math.pow(self.sigma, -0.7913)",
"def _exp_annealing(self, start, end, ratio):\n return start * (end / start) ** ratio",
"def _alpha(self, interval):\n return 1 - math.exp(-interval / self.period)",
"def expm1(x):\n return 0.0",
"def lo... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Commands for interacting with a bespoke executor. | def executor_cli(): | [
"def pythonCommandToExecute(*args, **kwargs):\n \n pass",
"def _recipe_run_commands(stakkr: StakkrActions, commands: dict):\n for title, cmd in commands.items():\n click.secho(' ↳ {}'.format(title))\n user = cmd['user'] if 'user' in cmd else 'root'\n stakkr.exec_cmd(cmd['contain... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Send the alert message to Slack. This wraps a subset of the Slack API incoming webhook or chat.postMessage API in order to make it behave closer to the default expectations of an AlertLib user, while still enabling customization of results. If the alert is HTML formatted, it will not be displayed correctly on Slack, bu... | def send_to_slack(self, channel,
simple_message=False,
intro='',
attachments=None,
link_names=1,
unfurl_links=False,
unfurl_media=True,
icon_url=None,
... | [
"def send_message_to_slack(text):\n\n try:\n post = {\n \"text\": \":fire: :sad_parrot: *OAG Data Ingest Error - Needs immediate attention:* OAG files are not regularly arriving in *dq-oag-data-ingest Pod* :sad_parrot: :fire:\",\n \"attachments\": [\n {\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Test to access to home page with error in url and response is 404 | def test_homepage_unexpected_error(self):
response = self.client.get('/home')
self.assertTrue(response.status_code, 404) | [
"def test_404(self):\n r = self.app.get('/canary/xyz')\n self.assertEqual(r.status_code, 404)\n self.assertIn('Page Not Found', r.data)\n self.assertNotIn('Try these instead', r.data)",
"def page_404(self, url):\n response = self.client.get(url)\n self.assertEqual(respons... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Test for a search in the url for a product's detail sheet, on a product that does NOT exist, returns 404 | def test_views_product_detail_not_registered(self):
response = self.client.get('/products/detail/11111111')
self.assertEquals(response.status_code, 404) | [
"def test_get_invalid_search_info(self):\n self.get_document_variants('_design/foo/_search_info/bar', Expect.RESPONSE_404.value, path_segment_count=3)\n self.get_document_variants('_design/foo/_search_info/bar', Expect.RESPONSE_404.value, True, path_segment_count=3)",
"def test_get_invalid_search(se... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Let the client `client_id` join the room. | def join(self, client_id: str):
self.players.append(client_id) | [
"def add_to_room(room_id, client):\n if not room_id in Room._rooms:\n Room._rooms[room_id] = []\n\n if Room._rooms[room_id].count(client) == 0:\n Room._rooms[room_id].append(client)",
"def on_make_join_request(self, room_id, user_id):\n builder = self.event_builder_facto... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Let the client `client_id` exit the room. | def exit(self, client_id: str):
if os.environ["AI_AGENT_ID"] in self.players:
self.players.remove(os.environ["AI_AGENT_ID"])
self.players.remove(client_id)
self.end_game() | [
"def exit(client_socket):\r\n client_socket.close()",
"def remove_from_room(room_id, client):\n if room_id in Room._rooms and client in Room._rooms[room_id]:\n print Room._rooms[room_id]\n Room._rooms[room_id].remove(client)\n print Room._rooms[room_id]",
"def client_d... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
perform a general setup, executing set_coords() for all cetagories | def setup():
global x_coordinates
for c in categories:
xy, nxy = set_coords( c )
n = nxy[ 0 ] * nxy[ 1 ]
coordinates[ c ] = xy
n_coords[ c ] = nxy
shapes[ c ] = ( n, sizes[ c ][ 1 ], sizes[ c ][ 0 ], 3 )
x ... | [
"def _set_centre(self,xc,yc,zc,vxc,vyc,vzc,reset_centre=False):\n if self.origin=='centre':\n\n warning=False\n if xc!=0.0 or yc!=0.0 or zc!=0.0:\n warning=True\n if vxc!=0.0 or vyc!=0.0 or vzc!=0.0:\n warning=True\n\n if warning:\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Returns the simple updown route from src to dst as a list of addresses | def get_route(srcx, dstx):
route = []
curi = honr.to_internal_repr(srcx)
dsti = honr.to_internal_repr(dstx)
ncax = honr.get_nearest_common_ancestor(srcx, dstx)
ncai = honr.to_internal_repr(ncax)
leftzero = honr.get_rank(srcx)
while curi != ncai:
route.append(honr.to_external_addr(cur... | [
"def find_all_path(G: nx.Graph, src: int, dst: int) -> list:\n return sorted(list(nx.all_simple_paths(G, src, dst)), key=lambda x : len(x))",
"def find_all_path(self, src: int, dst: int) -> list:\n return sorted(list(nx.all_simple_paths(self.G, src, dst)), key=lambda x: len(x))",
"def get_source_destination... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Returns True if this node (loc) should route a frame that has the given resender and destination addresses. In this case, "resender" is the neighbor that transmitted this frame to this node. | def should_route(resx, dstx, locx):
# Do not route, already at destination
if dstx == locx:
return False
# If the local address follows the resender in the ideal route
route = get_route(resx, dstx)
return (resx in route and locx in route
and route.index(locx) - route.index(resx)... | [
"def readyForNewRoute():\r\n if cLoca == cDest & cStat == ready & nDest == 0:\r\n return 1\r\n else:\r\n return 0",
"def is_referrer_of(self, r):\n if r.id_orig_h != self.id_orig_h:\n return False\n\n if self.url != r.referrer:\n return False\n\n if r... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Verifies all available switches accepted as an argument | def test_switch_combinations(self):
switches = ['-p', '--print', '-cp', '--copy', '-f', '--file', '-ro',
'--raw-output', '-s', '--shuffle', '-rl', '--remove-limit',
('-cs', ''), ('--character-set', '')]
# Sets up switches with required length argument
ar... | [
"def test_boolean_switches(self):\n switches = {'print': ['-p', '--print'],\n 'copy': ['-cp', '--copy'],\n 'shuffle': ['-s', '--shuffle'],\n 'raw_output': ['-ro', '--raw-output'],\n 'remove_limit': ['-rl', '--remove-limit']}\n\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Subtests for simple switches that store as True when included as an argument. | def test_boolean_switches(self):
switches = {'print': ['-p', '--print'],
'copy': ['-cp', '--copy'],
'shuffle': ['-s', '--shuffle'],
'raw_output': ['-ro', '--raw-output'],
'remove_limit': ['-rl', '--remove-limit']}
for dest,... | [
"def test_bool_direct(self):\n for source in (\"direct\", \"default\"):\n self.assertEqual(self.setting.detect_type(True, source), \"bool\")",
"def test_get_debug_variable_true():\n\n # Varible True\n assert get_debug(True, {\"debug\": False}, {\"debug\": False}) is True\n assert get_de... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Tests that providing a filename without an extension defaults the extension to .txt | def test_no_filename_extension(self):
expected_filename = os.path.join(self.test_dir, 'test_file.txt')
returned_filename = randstr_terminal._write_file('', 'test_file')
self.assertEqual(expected_filename, returned_filename) | [
"def test_force_ext_no_change(self, text_file):\n text_file.force_ext('.txt')\n assert text_file.extension == '.txt'\n assert '.txt.txt' not in text_file.dst_path.name",
"def test_force_ext_change_filepath(self, text_file):\n text_file.force_ext('.test')\n assert text_file.dst_p... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Test that randomized string correctly writes to file | def test_file_write(self):
args = self.parser.parse_args([self.str_len, '--file', '--raw-output'])
self.randstr_output(args).process_parsed_args()
output = sys.stdout.getvalue()
filename = os.path.join(self.test_dir, args.file)
with open(filename, 'r') as f:
random... | [
"def test_randomize_filename_is_working_properly(self):\n test_value = 'some/path/to/a/file.mp4'\n expected_result = 'some/path/to/a/file%(random_part)s.mp4'\n result = self.test_media_manager.randomize_file_name(test_value)\n\n random_part = result[len('some/path/to/a/file'):-len('.mp4'... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |