query stringlengths 9 9.05k | document stringlengths 10 222k | negatives listlengths 19 20 | metadata dict |
|---|---|---|---|
Gets the id_profissao of this AdicionalPersist. {{{adicional_persist_id_profissao_value}}} | def id_profissao(self):
return self._id_profissao | [
"def get_id_from_prof(self, prof):\n assert prof in self.professions_ids, \"Unknown profession: {}\".format(prof)\n return self.professions_ids[prof]",
"def get_id(self):\n\t\ttry:\n\t\t\tself.id = self.personaje['data']['results'][0]['id']\n\t\t\tprint(self.id)\n\t\texcept:\n\t\t\tprint('llama prim... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Sets the id_profissao of this AdicionalPersist. {{{adicional_persist_id_profissao_value}}} | def id_profissao(self, id_profissao):
self._id_profissao = id_profissao | [
"def get_id_from_prof(self, prof):\n assert prof in self.professions_ids, \"Unknown profession: {}\".format(prof)\n return self.professions_ids[prof]",
"def set_session_filming_invoice(session, filming_fee):\n session['cols_filming_invoice'] = filming_fee.id\n session.modified = True",... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Gets the id_nacionalidade of this AdicionalPersist. {{{adicional_persist_id_nacionalidade_value}}} | def id_nacionalidade(self):
return self._id_nacionalidade | [
"def get_id(self):\n return self[\"ds_id\"]",
"def get_ad_id(self):\n return self.get_item(conf.AD_ID_KEY)",
"def data_id(self) -> str:\n return self.entity_description.data_id",
"def get_id(self):\n return self.data['id']",
"def getId(self):\n return self.__disciplineID",... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Sets the id_nacionalidade of this AdicionalPersist. {{{adicional_persist_id_nacionalidade_value}}} | def id_nacionalidade(self, id_nacionalidade):
self._id_nacionalidade = id_nacionalidade | [
"def setIdMonodroga(self, id_monodroga):\r\n self.id_monodroga = id_monodroga",
"def set_id(self, value):\n return self._set_one_attribute(self.AttributeNames.ID, value)",
"def set_id(self, value=None, attribute=None):\n\n if value is None:\n if (attribute is not None and hasattr... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Gets the id_parentesco of this AdicionalPersist. {{{adicional_persist_id_parentesco_value}}} | def id_parentesco(self):
return self._id_parentesco | [
"def parent_id(self):\n if \"parentId\" in self._prop_dict:\n return self._prop_dict[\"parentId\"]\n else:\n return None",
"def _closure_parent_pk(self):\n if hasattr(self, \"%s_id\" % self._closure_parent_attr):\n return getattr(self, \"%s_id\" % self._closur... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Sets the id_parentesco of this AdicionalPersist. {{{adicional_persist_id_parentesco_value}}} | def id_parentesco(self, id_parentesco):
self._id_parentesco = id_parentesco | [
"def set_parent_id(self, parent_id):\n pass",
"def set_parent(self, node_id: int):\r\n self.parent = node_id",
"def parent_element_id(self, parent_element_id: int):\n\n self._parent_element_id = parent_element_id",
"def parent_folder_id(self, value):\n self.logger.warn(\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Gets the telefones of this AdicionalPersist. {{{adicional_persist_telefones_value}}} | def telefones(self):
return self._telefones | [
"def get_telefone(self):\r\n return self.__telefone",
"def telephone(self):\n return self.__telephone",
"def telephone(self):\n if self._telephone is None:\n return None\n elif len(self._telephone) == 1:\n return self._telephone[0]\n else:\n re... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Sets the telefones of this AdicionalPersist. {{{adicional_persist_telefones_value}}} | def telefones(self, telefones):
self._telefones = telefones | [
"def telecast_ids(self, telecast_ids):\n\n self._telecast_ids = telecast_ids",
"def set_telescope(self, telescope):\n self.telescope.set(telescope)",
"def get_telefone(self):\r\n return self.__telefone",
"def _set_directors(self, business: dict):\n directors_json = get_directors(se... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Updates pools by list in equipments | def put(self, request, *args, **kwargs):
server_pools = request.DATA
json_validate(SPECS.get('pool_put')).validate(server_pools)
verify_ports(server_pools)
locks_list = facade.create_lock(server_pools.get('server_pools'))
try:
response = facade_pool_deploy.update_rea... | [
"def updateMatingPool(self):\n self.matingPool = list(self.population)",
"def update_pools(self, capability: Optional[dict], service) -> None:\n if not capability:\n return\n\n pools = capability.get('pools', None)\n active_pools = set()\n if pools and isinstance(pool... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Deletes pools by list in equipments | def delete(self, request, *args, **kwargs):
pool_ids = kwargs['pool_ids'].split(';')
pools = facade.get_pool_by_ids(pool_ids)
pool_serializer = serializers.PoolV3Serializer(pools, many=True)
locks_list = facade.create_lock(pool_serializer.data)
try:
response = facade... | [
"def deletePredictor(self, list_):\n prdID = list_[0]\n equation = list_[1]\n self.forecastDict['EquationPools'][equation]['PredictorPool'].pop(prdID)\n self.displayForecastDict(self.forecastDict, onlyEquations=True)\n \n return",
"def _DeleteInventoryItems(self, models):... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Encode a base10 number to base62 string | def base62_encode(number):
result = ''
while number > 0:
result = base_map[number % 62] + result
number = number // 62
return result | [
"def encode(num, base):\n assert 2 <= base <= 36\n result = ''\n while num > 0:\n digit_str = get_digit_string(num, base)\n result = digit_str + result\n num = num / base\n return result",
"def convert_to_base62_string(number):\n digits = []\n if number == 0:\n digits... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Decode a base62 string to base10 number | def base62_decode(string):
result = 0
index = len(string)
for c in string:
result = result + base_map.index(c) * pow(62, index-1)
index = index-1
return result | [
"def decode(str_num, base):\n assert 2 <= base <= 36\n universal_list = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I',\n 'J','K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'] #create list of characters that can be used\n univ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Compile observation traffic_observation = self.observe_traffic_(traffic_df_cp) q_observation = self.observe_q_(self.q) Observe from traffic and queue, then compile a summary as information. | def observe(self, traffic_df):
if traffic_df is None:
raise ValueError("Please feed traffic.")
# Compile observation
last_traffic_ob = self.last_traffic_ob
last_q_ob = self.last_q_ob
new_q_ob = self.observe_q_(self.q)
self.last_traffic_ob = self.observe_traff... | [
"def _queue_analysis(self):",
"def timing_overview(gnss: str, dfobs: dict, PRNs: list, obst_used: list, nrepochs: int, logger: logging.Logger = None) -> dict:\n cFuncName = colored(os.path.basename(__file__), 'yellow') + ' - ' + colored(sys._getframe().f_code.co_name, 'green')\n\n # # determine index of hea... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
T_sgs represent the transport of the resolvedscale TKE by the fluctuations of SGS stresses | def t_sgs(self, p, avg):
upper1 = self.up * self.tau_11p + self.vp * self.tau_21p +\
self.w_uvp * self.tau_31p #uv grid
upper2 = self.up * self.tau_12p + self.vp * self.tau_22p +\
self.w_uvp * self.tau_32p #uv grid
upper3 = self.up * self.tau_13p + self.vp * self.tau_23p ... | [
"def s_stt(s): # sop_tv\n res = []\n for j in range(len(s)):\n res = res + [ttcube(s[j])]\n return res",
"def TTStation(self, name):\n if not name in ['TTa','TTb']: return\n for layer in ['U','X','V']: self.TTLayer(layer, name)\n return",
"def set_tsig(self, t):\n _ld... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
P_s represents the conversion of mean kinetic energy to resolvedscale TKE | def p_s(self, p, avg, mke):
p_s1 = self.up * self.up * mke.dudx + self.vp * self.up * mke.dvdx + self.w_uvp * self.up * mke.dwdx #uv grid
p_s2 = self.up * self.vp * mke.dudy + self.vp * self.vp * mke.dvdy + self.w_uvp * self.vp * mke.dwdy #uv grid
p_s3 = self.up * self.w_uvp * mke.dudz + se... | [
"def pressure(self, ps):\n return ps * self.sigma",
"def spressure(self) -> ObservationsSummaryStationPressure:\n return ObservationsSummaryStationPressure(self.summary[\"spressure\"])",
"def t_sgs(self, p, avg):\r\n\r\n upper1 = self.up * self.tau_11p + self.vp * self.tau_21p +\\\r\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Sample code to take outgoing transactions from an external DB and save as incoming to the default DB. | def out_to_incoming(self):
instances = []
for outgoing_transaction in OutgoingTransaction.objects.using('mpp40').filter(is_consumed=False).exclude(tx_name__icontains='bucket'):
incoming_transaction = IncomingTransaction()
for field in incoming_transaction._meta.fields:
if field in ou... | [
"def transaction():\n try:\n conn = connect_to_db()\n yield conn\n conn.commit()\n except Exception as e:\n print('\\nROLLBACK TRANSACTION!!!', e)\n conn.rollback()\n finally:\n conn.close()",
"def store_results(transactions):\r\n\r\n server='LAPTOP-N3JOPONO'\... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Checks for a user to have a character. | def has_char():
async def predicate(ctx):
ctx.character_data = await ctx.bot.pool.fetchrow(
'SELECT * FROM profile WHERE "user"=$1;', ctx.author.id
)
if ctx.character_data:
return True
raise NoCharacter()
return commands.check(predicate) | [
"def has_no_char():\n\n async def predicate(ctx):\n if await ctx.bot.pool.fetchrow(\n 'SELECT * FROM profile WHERE \"user\"=$1;', ctx.author.id\n ):\n raise NeedsNoCharacter()\n return True\n\n return commands.check(predicate)",
"def is_char(self, c=None):\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Checks for a user to have no character. | def has_no_char():
async def predicate(ctx):
if await ctx.bot.pool.fetchrow(
'SELECT * FROM profile WHERE "user"=$1;', ctx.author.id
):
raise NeedsNoCharacter()
return True
return commands.check(predicate) | [
"def has_char():\n\n async def predicate(ctx):\n ctx.character_data = await ctx.bot.pool.fetchrow(\n 'SELECT * FROM profile WHERE \"user\"=$1;', ctx.author.id\n )\n if ctx.character_data:\n return True\n raise NoCharacter()\n\n return commands.check(predicate)... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Checks for a user to be on an adventure. | def has_adventure():
async def predicate(ctx):
ctx.adventure_data = await ctx.bot.get_adventure(ctx.author)
if ctx.adventure_data:
return True
raise NeedsAdventure()
return commands.check(predicate) | [
"def has_no_adventure():\n\n async def predicate(ctx):\n if not await ctx.bot.get_adventure(ctx.author):\n return True\n raise NeedsNoAdventure()\n\n return commands.check(predicate)",
"def _check_user(self, user: User, storage_id: int, vm_id: int) -> Union[Literal[False], str]:\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Checks for a user to be on no adventure. | def has_no_adventure():
async def predicate(ctx):
if not await ctx.bot.get_adventure(ctx.author):
return True
raise NeedsNoAdventure()
return commands.check(predicate) | [
"async def not_in_game(self, ctx, user):\r\n await ctx.send(f\"{user.mention} You are not in this game! \" +\r\n \"Use the .join command to join the game\")",
"def user_not_eligible(self, user):\n return not self.event.user_eligible(user)",
"def check_no_user():\n try:\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Checks for a user to be in no guild. | def has_no_guild():
async def predicate(ctx):
if not await ctx.bot.pool.fetchval(
'SELECT guild FROM profile WHERE "user"=$1;', ctx.author.id
):
return True
raise NeedsNoGuild()
return commands.check(predicate) | [
"def check_on_guild(ctx: commands.Context) -> bool:\n if ctx.guild is None:\n raise errors.NoPrivateMessage()\n return True",
"def is_no_guild_leader():\n\n async def predicate(ctx):\n ctx.character_data = await ctx.bot.pool.fetchrow(\n 'SELECT * FROM profile WHERE \"user\"=$1;',... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Checks for a user to be guild officer or leader. | def is_guild_officer():
async def predicate(ctx):
ctx.character_data = await ctx.bot.pool.fetchrow(
'SELECT * FROM profile WHERE "user"=$1;', ctx.author.id
)
if (
ctx.character_data["guildrank"] == "Leader"
or ctx.character_data["guildrank"] == "Officer"
... | [
"async def member_guild_check(self, member: discord.Member):\n if member.guild.id in self.bot.premium_guilds:\n return True\n if await self.bot.is_owner(member):\n return True\n else:\n return False",
"def is_owner_or_admin(user, target_obj):\n return t... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Checks for a user to be guild leader. | def is_guild_leader():
async def predicate(ctx):
ctx.character_data = await ctx.bot.pool.fetchrow(
'SELECT * FROM profile WHERE "user"=$1;', ctx.author.id
)
if ctx.character_data["guildrank"] == "Leader":
return True
raise NoGuildPermissions()
return com... | [
"def is_no_guild_leader():\n\n async def predicate(ctx):\n ctx.character_data = await ctx.bot.pool.fetchrow(\n 'SELECT * FROM profile WHERE \"user\"=$1;', ctx.author.id\n )\n if ctx.character_data[\"guildrank\"] != \"Leader\":\n return True\n raise NeedsNoGuildLe... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Checks for a user not to be guild leader. | def is_no_guild_leader():
async def predicate(ctx):
ctx.character_data = await ctx.bot.pool.fetchrow(
'SELECT * FROM profile WHERE "user"=$1;', ctx.author.id
)
if ctx.character_data["guildrank"] != "Leader":
return True
raise NeedsNoGuildLeader()
return ... | [
"def has_no_guild():\n\n async def predicate(ctx):\n if not await ctx.bot.pool.fetchval(\n 'SELECT guild FROM profile WHERE \"user\"=$1;', ctx.author.id\n ):\n return True\n raise NeedsNoGuild()\n\n return commands.check(predicate)",
"def is_guild_leader():\n\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Checks for a user to be the leader of an alliance. | def is_alliance_leader():
async def predicate(ctx):
async with ctx.bot.pool.acquire() as conn:
if not hasattr(ctx, "character_data"):
ctx.character_data = await conn.fetchrow(
'SELECT * FROM profile WHERE "user"=$1;', ctx.author.id
)
... | [
"def is_guild_leader():\n\n async def predicate(ctx):\n ctx.character_data = await ctx.bot.pool.fetchrow(\n 'SELECT * FROM profile WHERE \"user\"=$1;', ctx.author.id\n )\n if ctx.character_data[\"guildrank\"] == \"Leader\":\n return True\n raise NoGuildPermission... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Checks whether an alliance owns a city. | def owns_city():
async def predicate(ctx):
async with ctx.bot.pool.acquire() as conn:
alliance = await conn.fetchval(
'SELECT alliance FROM guild WHERE "id"=$1', ctx.character_data["guild"]
)
owned_city = await conn.fetchval(
'SELECT name ... | [
"def owns_no_city():\n\n async def predicate(ctx):\n async with ctx.bot.pool.acquire() as conn:\n alliance = await conn.fetchval(\n 'SELECT alliance FROM guild WHERE \"id\"=$1', ctx.character_data[\"guild\"]\n )\n owned_city = await conn.fetchval(\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Checks whether an alliance owns no city. | def owns_no_city():
async def predicate(ctx):
async with ctx.bot.pool.acquire() as conn:
alliance = await conn.fetchval(
'SELECT alliance FROM guild WHERE "id"=$1', ctx.character_data["guild"]
)
owned_city = await conn.fetchval(
'SELECT na... | [
"def owns_city():\n\n async def predicate(ctx):\n async with ctx.bot.pool.acquire() as conn:\n alliance = await conn.fetchval(\n 'SELECT alliance FROM guild WHERE \"id\"=$1', ctx.character_data[\"guild\"]\n )\n owned_city = await conn.fetchval(\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Checks for a user to be in a class line. | def is_class(class_):
async def predicate(ctx):
async with ctx.bot.pool.acquire() as conn:
ret = await conn.fetchval(
'SELECT class FROM profile WHERE "user"=$1;', ctx.author.id
)
if (check := ctx.bot.in_class_line(ret, class_)) and class_ == "Ranger":
... | [
"def __class_id_checker(self, line_list, len_line):\n if len_line == 0:\n print(\"** class name missing **\")\n return 1\n elif line_list[0] not in self.classes:\n print(\"** class doesn't exist **\")\n return 1\n elif len_line == 1:\n prin... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Checks for a user to have a god. | def has_god():
async def predicate(ctx):
if not hasattr(ctx, "character_data"):
ctx.character_data = await ctx.bot.pool.fetchrow(
'SELECT * FROM profile WHERE "user"=$1;', ctx.author.id
)
if ctx.character_data["god"]:
return True
raise Nee... | [
"def is_god():\n\n def predicate(ctx):\n return ctx.author.id in ctx.bot.gods\n\n return commands.check(predicate)",
"def check_god(request):\n\n godgroup = Group.objects.get(name=\"Gods\")\n if godgroup in request.user.groups.all():\n return True\n else:\n return False",
"as... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Checks for a user to be a god. | def is_god():
def predicate(ctx):
return ctx.author.id in ctx.bot.gods
return commands.check(predicate) | [
"def has_god():\n\n async def predicate(ctx):\n if not hasattr(ctx, \"character_data\"):\n ctx.character_data = await ctx.bot.pool.fetchrow(\n 'SELECT * FROM profile WHERE \"user\"=$1;', ctx.author.id\n )\n if ctx.character_data[\"god\"]:\n return Tru... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
__init__(self, g, k) > GenKeySource | def __init__(self, *args):
this = _wali.new_GenKeySource(*args)
try: self.this.append(this)
except: self.this = this | [
"def __init__(self):\n rng = Random.new().read\n RSAkey = RSA.generate(1024, rng)\n self.privatekey = RSAkey\n self.publicKey = self.privatekey.publickey()",
"def __init__(self, *args):\n this = _wali.new_KeyPair(*args)\n try: self.this.append(this)\n except: self.... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
extend(self, se) > SemElemPtr | def extend(self, *args):
return _wali.SemElem_extend(self, *args) | [
"def extend(self, *args):\n return _wali.SemElemPtr_extend(self, *args)",
"def pyextend(self, *args):\n #Deref smart pointer if needed\n if hasattr(args[1], '__deref__'):\n tmp = list(args)\n tmp[1] = tmp[1].__deref__()\n args = tuple(tmp)\n\n\n return ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
under_approximates(self, that) > bool | def under_approximates(self, *args):
return _wali.SemElem_under_approximates(self, *args) | [
"def is_approx_equal(self, other):\n raise NotImplementedError",
"def under_approximates(self, *args):\n return _wali.PySemElem_under_approximates(self, *args)",
"def approx_equals(a, b):\n return (a - b) < 1.5e-16",
"def loses(self):\n return not (-2.5 < self.x < 2.5 and -0.262 < self... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
container_less_than(self, other) > bool | def container_less_than(self, *args):
return _wali.SemElem_container_less_than(self, *args) | [
"def container_less_than(self, *args):\n return _wali.SemElemPtr_container_less_than(self, *args)",
"def __gt__(self, other):\n if isinstance(other, self.__class__):\n result = self.__class__(self.width, self.height)\n\n for index, value in enumerate(self):\n res... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
extend(self, se) > SemElemPtr | def extend(self, *args):
return _wali.SemElemPtr_extend(self, *args) | [
"def extend(self, *args):\n return _wali.SemElem_extend(self, *args)",
"def pyextend(self, *args):\n #Deref smart pointer if needed\n if hasattr(args[1], '__deref__'):\n tmp = list(args)\n tmp[1] = tmp[1].__deref__()\n args = tuple(tmp)\n\n\n return _wa... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
combine(self, se) > SemElemPtr | def combine(self, *args):
return _wali.SemElemPtr_combine(self, *args) | [
"def pycombine(self, *args):\n #Deref smart pointer if needed\n if hasattr(args[1], '__deref__'):\n tmp = list(args)\n tmp[1] = tmp[1].__deref__()\n args = tuple(tmp)\n\n\n return _wali.PySemElemPtr_pycombine(self, *args)",
"def pycombine(self, *args):\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
diff(self, se) > SemElemPtr | def diff(self, *args):
return _wali.SemElemPtr_diff(self, *args) | [
"def diff(self, *args):\n return _wali.PySemElem_diff(self, *args)",
"def pydiff(self, *args):\n return _wali.PySemElemPtr_pydiff(self, *args)",
"def delta(self, *args):\n return _wali.PySemElemPtr_delta(self, *args)",
"def delta(self, *args):\n return _wali.PySemElem_delta(self, *... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
extend_and_diff(self, next, subtrahend) > SemElemPtr | def extend_and_diff(self, *args):
return _wali.SemElemPtr_extend_and_diff(self, *args) | [
"def extend_and_diff(self, *args):\n return _wali.PySemElem_extend_and_diff(self, *args)",
"def pyextend_and_diff(self, *args):\n return _wali.PySemElemPtr_pyextend_and_diff(self, *args)",
"def extend(self, *args):\n return _wali.SemElemPtr_extend(self, *args)",
"def extend(self, *args):\... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
container_less_than(self, other) > bool | def container_less_than(self, *args):
return _wali.SemElemPtr_container_less_than(self, *args) | [
"def container_less_than(self, *args):\n return _wali.SemElem_container_less_than(self, *args)",
"def __gt__(self, other):\n if isinstance(other, self.__class__):\n result = self.__class__(self.width, self.height)\n\n for index, value in enumerate(self):\n result... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
__init__(self) > KeyPair __init__(self, first, second) > KeyPair | def __init__(self, *args):
this = _wali.new_KeyPair(*args)
try: self.this.append(this)
except: self.this = this | [
"def generateKeyPair(cls):",
"def __init__(self, first_id=1):\n\n self._key_base = first_id\n self._last_id = None",
"def __init__(self, key):\n # self.key = key.decode(\"hex\") # Python 2\n self.key = bytes.fromhex(key)",
"def __init__( self, public_key, secret_multiplier ):\n\n self.... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
strhashfn(str) > unsigned long | def strhashfn(*args):
return _wali.strhashfn(*args) | [
"def SbString_hash(*args) -> \"uint32_t\":\n return _coin.SbString_hash(*args)",
"def hash_string(string):\r\n return hashlib.sha256(string.encode('utf-8')).hexdigest()",
"def hash(*args) -> \"uint32_t\":\n return _coin.SbString_hash(*args)",
"def hash_string(obj: str) -> int:\n # Similar to `... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
pycombine(self, se) > PySemElemPtr | def pycombine(self, *args):
#Deref smart pointer if needed
if hasattr(args[1], '__deref__'):
tmp = list(args)
tmp[1] = tmp[1].__deref__()
args = tuple(tmp)
return _wali.PySemElem_pycombine(self, *args) | [
"def pycombine(self, *args):\n #Deref smart pointer if needed\n if hasattr(args[1], '__deref__'):\n tmp = list(args)\n tmp[1] = tmp[1].__deref__()\n args = tuple(tmp)\n\n\n return _wali.PySemElemPtr_pycombine(self, *args)",
"def combine(self, *args):\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
pyextend(self, se) > PySemElemPtr | def pyextend(self, *args):
#Deref smart pointer if needed
if hasattr(args[1], '__deref__'):
tmp = list(args)
tmp[1] = tmp[1].__deref__()
args = tuple(tmp)
return _wali.PySemElem_pyextend(self, *args) | [
"def extend(self, *args):\n return _wali.SemElemPtr_extend(self, *args)",
"def extend(self, *args):\n return _wali.SemElem_extend(self, *args)",
"def pyextend_and_diff(self, *args):\n return _wali.PySemElemPtr_pyextend_and_diff(self, *args)",
"def extend_and_diff(self, *args):\n re... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
delta(self, se) > SemElemPtrPair | def delta(self, *args):
return _wali.PySemElem_delta(self, *args) | [
"def delta(self, *args):\n return _wali.PySemElemPtr_delta(self, *args)",
"def diff(self, *args):\n return _wali.SemElemPtr_diff(self, *args)",
"def diff(self, *args):\n return _wali.PySemElem_diff(self, *args)",
"def pydiff(self, *args):\n return _wali.PySemElemPtr_pydiff(self, *a... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
pyequal(self, se) > bool | def pyequal(self, *args):
return _wali.PySemElem_pyequal(self, *args) | [
"def pyequal(self, *args):\n return _wali.PySemElemPtr_pyequal(self, *args)",
"def _equal(self, condition: bool) -> bool:\n return not(condition ^ self.same)",
"def __eq__(self, type: 'SoType') -> \"SbBool\":\n return _coin.SoType___eq__(self, type)",
"def __eq__(self, field: 'SoMFVec4ub'... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
pyunder_approximates(self, se) > bool | def pyunder_approximates(self, *args):
return _wali.PySemElem_pyunder_approximates(self, *args) | [
"def under_approximates(self, *args):\n return _wali.PySemElem_under_approximates(self, *args)",
"def under_approximates(self, *args):\n return _wali.SemElem_under_approximates(self, *args)",
"def _use_approx(self, method='auto'):\n if method == 'auto':\n if self.data.shape[0] > ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
under_approximates(self, se) > bool | def under_approximates(self, *args):
return _wali.PySemElem_under_approximates(self, *args) | [
"def under_approximates(self, *args):\n return _wali.SemElem_under_approximates(self, *args)",
"def pyunder_approximates(self, *args):\n return _wali.PySemElem_pyunder_approximates(self, *args)",
"def loses(self):\n return not (-2.5 < self.x < 2.5 and -0.262 < self.phi < 0.262)",
"def has... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
extend_and_diff(self, next, subtrahend) > sem_elem_t | def extend_and_diff(self, *args):
return _wali.PySemElem_extend_and_diff(self, *args) | [
"def extend_and_diff(self, *args):\n return _wali.SemElemPtr_extend_and_diff(self, *args)",
"def pyextend_and_diff(self, *args):\n return _wali.PySemElemPtr_pyextend_and_diff(self, *args)",
"def extend(self, *args):\n return _wali.SemElem_extend(self, *args)",
"def extend(self, *args):\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
diff(self, se) > sem_elem_t | def diff(self, *args):
return _wali.PySemElem_diff(self, *args) | [
"def diff(self, *args):\n return _wali.SemElemPtr_diff(self, *args)",
"def delta(self, *args):\n return _wali.PySemElem_delta(self, *args)",
"def delta(self, *args):\n return _wali.PySemElemPtr_delta(self, *args)",
"def pydiff(self, *args):\n return _wali.PySemElemPtr_pydiff(self, ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
__init__(self) > SemElemPtrPair __init__(self, first, second) > SemElemPtrPair | def __init__(self, *args):
this = _wali.new_SemElemPtrPair(*args)
try: self.this.append(this)
except: self.this = this | [
"def __init__(self, *args):\n this = _wali.new_PySemElemPtrPair(*args)\n try: self.this.append(this)\n except: self.this = this",
"def __init__(self, *args):\n this = _wali.new_PySemElemPtr(*args)\n try: self.this.append(this)\n except: self.this = this",
"def test_pair... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
__init__(self, t=None) > PySemElemPtr | def __init__(self, *args):
this = _wali.new_PySemElemPtr(*args)
try: self.this.append(this)
except: self.this = this | [
"def __init__(self, *args):\n this = _wali.new_PySemElemPtrPair(*args)\n try: self.this.append(this)\n except: self.this = this",
"def __init__(self, *args):\n this = _wali.new_SemElemPtrPair(*args)\n try: self.this.append(this)\n except: self.this = this",
"def __init_... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
pycombine(self, se) > PySemElemPtr | def pycombine(self, *args):
#Deref smart pointer if needed
if hasattr(args[1], '__deref__'):
tmp = list(args)
tmp[1] = tmp[1].__deref__()
args = tuple(tmp)
return _wali.PySemElemPtr_pycombine(self, *args) | [
"def pycombine(self, *args):\n #Deref smart pointer if needed\n if hasattr(args[1], '__deref__'):\n tmp = list(args)\n tmp[1] = tmp[1].__deref__()\n args = tuple(tmp)\n\n\n return _wali.PySemElem_pycombine(self, *args)",
"def combine(self, *args):\n ret... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
delta(self, se) > SemElemPtrPair | def delta(self, *args):
return _wali.PySemElemPtr_delta(self, *args) | [
"def delta(self, *args):\n return _wali.PySemElem_delta(self, *args)",
"def diff(self, *args):\n return _wali.SemElemPtr_diff(self, *args)",
"def diff(self, *args):\n return _wali.PySemElem_diff(self, *args)",
"def pydiff(self, *args):\n return _wali.PySemElemPtr_pydiff(self, *args... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
pyequal(self, se) > bool | def pyequal(self, *args):
return _wali.PySemElemPtr_pyequal(self, *args) | [
"def pyequal(self, *args):\n return _wali.PySemElem_pyequal(self, *args)",
"def _equal(self, condition: bool) -> bool:\n return not(condition ^ self.same)",
"def __eq__(self, type: 'SoType') -> \"SbBool\":\n return _coin.SoType___eq__(self, type)",
"def __eq__(self, field: 'SoMFVec4ub') -... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
pyextend_and_diff(self, next, subtrahend) > PySemElemPtr | def pyextend_and_diff(self, *args):
return _wali.PySemElemPtr_pyextend_and_diff(self, *args) | [
"def extend_and_diff(self, *args):\n return _wali.SemElemPtr_extend_and_diff(self, *args)",
"def pyextend(self, *args):\n #Deref smart pointer if needed\n if hasattr(args[1], '__deref__'):\n tmp = list(args)\n tmp[1] = tmp[1].__deref__()\n args = tuple(tmp)\n\... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
pydiff(self, se) > PySemElemPtr | def pydiff(self, *args):
return _wali.PySemElemPtr_pydiff(self, *args) | [
"def diff(self, *args):\n return _wali.SemElemPtr_diff(self, *args)",
"def diff(self, *args):\n return _wali.PySemElem_diff(self, *args)",
"def delta(self, *args):\n return _wali.PySemElemPtr_delta(self, *args)",
"def delta(self, *args):\n return _wali.PySemElem_delta(self, *args)"... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
__init__(self) > PySemElemPtrPair __init__(self, first, second) > PySemElemPtrPair | def __init__(self, *args):
this = _wali.new_PySemElemPtrPair(*args)
try: self.this.append(this)
except: self.this = this | [
"def __init__(self, *args):\n this = _wali.new_SemElemPtrPair(*args)\n try: self.this.append(this)\n except: self.this = this",
"def __init__(self, *args):\n this = _wali.new_PySemElemPtr(*args)\n try: self.this.append(this)\n except: self.this = this",
"def pycombine(s... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
__init__(self) > Trans __init__(self, _from, stack, to, se) > Trans | def __init__(self, *args):
this = _wali.new_Trans(*args)
try: self.this.append(this)
except: self.this = this | [
"def __init__(self, *args):\n this = _wali.new_TransVector(*args)\n try: self.this.append(this)\n except: self.this = this",
"def __init__(self):\n this = _coin.new_SoMatrixTransform()\n try:\n self.this.append(this)\n except __builtin__.Exception:\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
copy(self) > Trans copy(self, f, s, t) > Trans | def copy(self, *args):
return _wali.Trans_copy(self, *args) | [
"def copy(self):\n return TransformNode(self.input[0], self.exprs, self.keep_index)",
"def copied(object, original):",
"def copyFrom(self, f: 'SoField') -> \"void\":\n return _coin.SoField_copyFrom(self, f)",
"def copyInPlace(*args, **kwargs):\n \n pass",
"def _apply_to_copy(self, fu... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
poststar_eps_closure(self, se) > SemElemPtr | def poststar_eps_closure(self, *args):
return _wali.Trans_poststar_eps_closure(self, *args) | [
"def poststar(self, *args):\n return _wali.WPDS_poststar(self, *args)",
"def create_sems(sig):\r\n\r\n\r\n\r\n\r\n\r\n def create_new_sem(sem_type):\r\n \"\"\" Gets parameter sem_type in ('Instruction', 'Schedule', 'AdminEvent'). Returns updated tuple (current_inst, current_sched, current_evt)\r\... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
__init__(self, arg2) > TransSetImpl | def __init__(self, *args):
this = _wali.new_TransSetImpl(*args)
try: self.this.append(this)
except: self.this = this | [
"def __init__(self, *args):\n this = _wali.new_Trans(*args)\n try: self.this.append(this)\n except: self.this = this",
"def __init__(self, *args):\n this = _wali.new_TransVector(*args)\n try: self.this.append(this)\n except: self.this = this",
"def __init__(self, db_obj... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
erase(self, t) > ITrans | def erase(self, *args):
return _wali.TransSet_erase(self, *args) | [
"def _undo_trajectory(self):\n for t in self._traj:\n self._mask.__setitem__(t, 0)",
"def _undo_trajectory(self):\n for t in self._traj:\n self._mask[t] = 0",
"def erase(self):\n print('Do something before erase')\n super(DummyNode, self).erase()\n print(... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
__getslice__(self, i, j) > TransVector | def __getslice__(self, *args):
return _wali.TransVector___getslice__(self, *args) | [
"def __getitem__(self, *args):\n return _wali.TransVector___getitem__(self, *args)",
"def __getslice__(self, *args, **kwargs):\n return _digital_swig.gr_complex_vector___getslice__(self, *args, **kwargs)",
"def __getslice__(self, *args, **kwargs):\n return _digital_swig.unsigned_int_vector_... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
__getitem__(self, slice) > TransVector | def __getitem__(self, *args):
return _wali.TransVector___getitem__(self, *args) | [
"def __getslice__(self, *args):\n return _wali.TransVector___getslice__(self, *args)",
"def __getitem__(self, i):\n try:\n if type(i) == slice:\n return Vector(self.data[i])\n return self.data[i]\n except:\n raise IndexError(\"vector index out o... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
__init__(self) > TransVector __init__(self, arg2) > TransVector | def __init__(self, *args):
this = _wali.new_TransVector(*args)
try: self.this.append(this)
except: self.this = this | [
"def __init__(self):\n this = _coin.new_SoTransformVec3f()\n try:\n self.this.append(this)\n except __builtin__.Exception:\n self.this = this",
"def __init__(self, *args):\n this = _coin.new_SbVec2f(*args)\n try:\n self.this.append(this)\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
is_initial_state(self, key) > bool | def is_initial_state(self, *args):
return _wali.WFA_is_initial_state(self, *args) | [
"def is_initial(self):\n if State.initial_states is None:\n return False\n\n if isinstance(State.initial_states, list):\n return self.name in State.initial_states\n return self.name == self.initial_states",
"def IsInitOnly(self) -> bool:",
"def initialized(self) -> boo... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
erase_state(self, q) > bool | def erase_state(self, *args):
return _wali.WFA_erase_state(self, *args) | [
"def removeState(self, state: 'ScXMLStateElt') -> \"void\":\n return _coin.ScXMLParallelElt_removeState(self, state)",
"def removeState(self, state: 'ScXMLStateElt') -> \"void\":\n return _coin.ScXMLStateElt_removeState(self, state)",
"def removeState(self, state: 'ScXMLStateElt') -> \"void\":\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
intersect(self, fa) > WFA | def intersect(self, *args):
return _wali.WFA_intersect(self, *args) | [
"def intersect_worklist(self, *args):\n return _wali.WFA_intersect_worklist(self, *args)",
"def intersect_cross(self, *args):\n return _wali.WFA_intersect_cross(self, *args)",
"def intersect(i1, i2):\n return i1.inf <= i2.sup and i2.inf <= i1.sup",
"def intersect(self, *args) -> \"SbBool\... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
intersect_worklist(self, wmaker, fa, dest) | def intersect_worklist(self, *args):
return _wali.WFA_intersect_worklist(self, *args) | [
"def intersect(self, *args):\n return _wali.WFA_intersect(self, *args)",
"def intersection(*fsms):\n return parallel(fsms, all)",
"def intersects(*args, **kwargs):\n \n pass",
"def __woverlap(wa, wb):\n wrange = wa[[0,-1]]\n overlap = (np.searchsorted(wrange, wb) == 1)\n iover... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
intersect_cross(self, wmaker, fa, dest) | def intersect_cross(self, *args):
return _wali.WFA_intersect_cross(self, *args) | [
"def intersect(self, *args):\n return _wali.WFA_intersect(self, *args)",
"def intersect_worklist(self, *args):\n return _wali.WFA_intersect_worklist(self, *args)",
"def wise_crossmatch(gaia_cat, gaia_wise, gaia_wise_crossref, wise_cat, twomass_cat):\n num_entries = len(wise_cat['ra'])\n num_... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
is_accepted_with_nonzero_weight(self, word) > bool | def is_accepted_with_nonzero_weight(self, *args):
return _wali.WFA_is_accepted_with_nonzero_weight(self, *args) | [
"def has_weight(self) -> bool:\n return self.weight > 0.0",
"def is_nominalization(word):\r\n if len(wn.synsets(word)) == 0:\r\n return False\r\n\r\n if len(wn.synsets(word)[0].lemmas()[0].derivationally_related_forms()) == 0:\r\n return False\r\n\r\n derive = wn.synsets(word)[0].lem... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
determinize(self) > WFA determinize(self, weight_gen) > WFA | def determinize(self, *args):
return _wali.WFA_determinize(self, *args) | [
"def test_expectation_weighted(self):\n self._test_expectation(weights=self._generate_weights())",
"def muscle_activation_opt():\n # number of floats in one individual\n IND_SIZE = 12 # 20\n # bounds of the uniform distribution creating the float values for the individuals\n START = 0.0 # -0.... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
semideterminize(self) > WFA semideterminize(self, weight_gen) > WFA | def semideterminize(self, *args):
return _wali.WFA_semideterminize(self, *args) | [
"def NielsenGenerators(F):\n yield Automorphism(F,{1:F.word([2]),2:F.word([1])}) # swap first two basis elements\n yield Automorphism(F,dict({i:F.word([i+1]) for i in range(1,F.rank)},**{F.rank:F.word([1])})) # cycically permute basis\n yield Automorphism(F,{1:F.word([-1])}) # invert first basis element\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
is_isomorphism(left, left_states, right, right_states, check_weights) > bool | def is_isomorphism(*args):
return _wali.WFA_is_isomorphism(*args) | [
"def WFA_is_isomorphism(*args):\n return _wali.WFA_is_isomorphism(*args)",
"def testIsomorphism(g1, g2):\n G = disjointUnion(g1, g2)\n\n return count_isomorphism(G, [], [])",
"def check_isomorphism(mol1, mol2, filter_structures=True, convert_to_single_bonds=False):\n\n if mol1 is None or mol2 is None:... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
outgoing_trans_set(self, state, symbol) > TransSet | def outgoing_trans_set(self, *args):
return _wali.WFA_outgoing_trans_set(self, *args) | [
"def tr_to(self, state):\n return [t for t in self.transitions if t.fstate == state]",
"def dst_state(self, src_state: str, symbol: str) -> str:\n if src_state not in self.states:\n print(\"error : the state '\" + str(src_state) + \"' is not an existing state.\")\n return\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
WFA_is_isomorphism(left, left_states, right, right_states, check_weights) > bool | def WFA_is_isomorphism(*args):
return _wali.WFA_is_isomorphism(*args) | [
"def is_isomorphism(*args):\n return _wali.WFA_is_isomorphism(*args)",
"def _is_legal_undirected_edge_weights_matrix(W):\n if boolmatrix_any(W < 0):\n return False\n elif not is_symmetric(W):\n return False\n elif boolmatrix_any(W.diagonal() != 0):\n return False\n\n return... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
simplify(input, tester) > WFA | def simplify(*args):
return _wali.simplify(*args) | [
"def simplify(units):\n pass",
"def test_simplify(self):\r\n self.assertTrue(str(Fraction(9, 27).simplify()) == \"1/3\")\r\n self.assertFalse(str(Fraction(9, 27).simplify()) == str(Fraction(2, 3)))\r\n self.assertTrue(str(Fraction(-9, -27).simplify()) == str(Fraction(-1, -3)))\r\n s... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
__init__(self, arg2) > KeySet | def __init__(self, *args):
this = _wali.new_KeySet(*args)
try: self.this.append(this)
except: self.this = this | [
"def __init__(self, *args):\n this = _wali.new_KeyPair(*args)\n try: self.this.append(this)\n except: self.this = this",
"def __init__(self, keys=None):\n UserDict.__init__(self)\n self._keys = keys if keys is not None else ParameterSet()",
"def __init__(self):\n this =... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
replace_rule(self, from_state, from_stack, to_state, se) > bool | def replace_rule(self, *args):
return _wali.WPDS_replace_rule(self, *args) | [
"def replace_rule(self, *args):\n return _wali.EWPDS_replace_rule(self, *args)",
"def _substitute(self, rule):\n prev = self.prev_symbol\n prev.next_symbol._delete()\n prev.next_symbol._delete()\n prev.append(rule)\n if not prev.check():\n prev.next_symbol.chec... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
erase_rule(self, from_state, from_stack, to_state, to_stack1, to_stack2) > bool | def erase_rule(self, *args):
return _wali.WPDS_erase_rule(self, *args) | [
"def delete_mark_rule(src_ip, environment):\n assert environment in _SET_BY_ENVIRONMENT, \\\n \"Unknown environment: %r\" % environment\n\n target_set = _SET_BY_ENVIRONMENT[environment]\n rm_ip_set(target_set, src_ip)",
"def erase_state(self, *args):\n return _wali.WFA_erase_state(self, *ar... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
poststar(self, input) > WFA | def poststar(self, *args):
return _wali.WPDS_poststar(self, *args) | [
"def _post(self, *args, **kwargs):\n return _wavelet_swig.squash_ff_sptr__post(self, *args, **kwargs)",
"def score(self, input, acts):\n return None",
"def poststar_eps_closure(self, *args):\n return _wali.Trans_poststar_eps_closure(self, *args)",
"def _post(self, *args, **kwargs):\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
is_pds_state(self, k) > bool | def is_pds_state(self, *args):
return _wali.WPDS_is_pds_state(self, *args) | [
"def HasKST(self):\n return self.__has('KST')",
"def HasKLD(self):\n return self.__has('KLD')",
"def HasKSD(self):\n return self.__has('KSD')",
"def has(self, state):\n for node in self.heap:\n if node.state == state:\n return True\n return False",
... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
add_rule(self, from_state, from_stack, to_state, se) > bool | def add_rule(self, *args):
return _wali.EWPDS_add_rule(self, *args) | [
"def add(self, state, test, dst, action=None, tag=None):\n if state not in self.rules:\n self.rules[state] = []\n if dst not in self.rules:\n self.rules[dst] = []\n self.rules[state].append((test, dst, action, tag)) # REM: auto-tag \"global\" rules?",
"def addRule(self,... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
replace_rule(self, from_state, from_stack, to_state, to_stack1, to_stack2, se) > bool | def replace_rule(self, *args):
return _wali.EWPDS_replace_rule(self, *args) | [
"def replace_rule(self, *args):\n return _wali.WPDS_replace_rule(self, *args)",
"def _substitute(self, rule):\n prev = self.prev_symbol\n prev.next_symbol._delete()\n prev.next_symbol._delete()\n prev.append(rule)\n if not prev.check():\n prev.next_symbol.check... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Read the "fof_special_particles" files and return an array of the positions of each particles belonging to a group. | def read_groups_particles(filename):
f = open(filename,'r')
Ntot = np.fromstring(f.read(4),np.int32)[0]
Pos = np.fromstring(f.read(3*4*Ntot),np.float32)
Pos.shape = (Ntot,3)
f.close()
return Pos, Ntot | [
"def read_observable_particles(self, data_set_name=\"\"):\n with _h5py.File(self._filename, \"r\") as f:\n group_path = \"readdy/observables/particles/\" + data_set_name\n if not group_path in f:\n raise ValueError(\"The particles observable was not recorded in the file o... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
check we can run ctapipefileinfo and get results | def test_fileinfo(tmp_path, dl1_image_file):
import yaml
from astropy.table import Table
index_file = tmp_path / "index.fits"
command = f"ctapipe-fileinfo {dl1_image_file} --output-table {index_file}"
output = subprocess.run(command.split(" "), capture_output=True, encoding="utf-8")
assert outp... | [
"def test_get_checker_results(self):\n pass",
"def check_external_tools(self):\n self.path_tesseract = shutil.which(self.cmd_tesseract)\n if self.path_tesseract is None:\n eprint(\"tesseract not found. Aborting...\")\n sys.exit(1)\n #\n self.tesseract_can_t... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Return the vertices of the cube at positions x, y, z with the size of 2n | def cube_vertices(x, y, z, n):
return [
x - n, y + n, z - n, x - n, y + n, z + n, x + n, y + n, z + n, x + n, y + n, z - n, # top
x - n, y - n, z - n, x + n, y - n, z - n, x + n, y - n, z + n, x - n, y - n, z + n, # bottom
x - n, y - n, z - n, x - n, y - n, z + n, x - n, y + n, z + n, x -... | [
"def cube():\n vtype = [('a_position', np.float32, 3),\n ('a_normal', np.float32, 3),\n ('a_color', np.float32, 4)]\n # Vertices positions\n v = [[1, 1, 1], [-1, 1, 1], [-1, -1, 1], [1, -1, 1],\n [1, -1, -1], [1, 1, -1], [-1, 1, -1], [-1, -1, -1]]\n # Face Normals\n n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Returns a tuple representing the sector for the given block position | def sectorize(position):
x, y, z = normalize(position)
x, y, z = x // SECTOR_SIZE, y // SECTOR_SIZE, z // SECTOR_SIZE
return (x, 0, z) | [
"def sector(self, key: Tuple[int, int]) -> 'FqeData':\n return self._civec[key]",
"def get_sector(angle_of_resource):\n\n # To make sure angle_of_resource is within (0, 360)\n angle_of_resource %= 360\n\n sector = ceil(angle_of_resource / 45.0)\n\n return sector",
"def sector(... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Add a block with the selected texture and placement to the world | def add_block(self, position, texture, immediate=True):
if position in self.world:
self.remove_block(position, immediate)
self.world[position] = texture
self.sectors.setdefault(sectorize(position), []).append(position)
if immediate:
if self.exposed(position):
... | [
"def add_block(self, position, texture, immediate=True, zoom=0.5): \n x, y, z = position\n \n if position in self.world:\n self.remove_block(position, immediate)\n self.world[position] = texture\n self.world_zoom[position] = zoom\n self.sectors.setdefault(se... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
I make sure that all the blocks in the given sector that SHOULD be seen, are drawn to the canvas. like little happy clouds. that happy cloud will be our lil' secret. | def show_sector(self, sector):
for position in self.sectors.get(sector, []):
if position not in self.shown and self.exposed(position):
self.show_block(position, False) | [
"def select_sector(self, sector=1):\n if self.sector == sector:\n print(f'Already in sector {sector}.')\n return\n elif sector not in self.sector_table['sector']:\n print(f'Sector {sector} does not cover this region. Please refer to sector table.')\n return\... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Move from the previous sector of the world, to the 'after'. (So philosphical. is there an after?) Anyway......... subdividing the world into sectors help render the world quicker. | def change_sector(self, before, after):
before_set = set()
after_set = set()
pad = 4
for dx in xrange(-pad, pad + 1):
for dy in [0]:
for dz in xrange(-pad, pad + 1): # thank god for google, math is hard
if dx ** 2 + dy ** 2 + dz ** 2 > (pa... | [
"def move_backward(self):\n self.jerry_turtle.back(50)",
"def at_after_move(self, source_location):\r\n pass",
"def move(self):\n for seg_index in range(len(self.segments) - 1, 0, -1):\n new_x = self.segments[seg_index - 1].xcor()\n new_y = self.segments[seg_index - 1]... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Add func to the internal queue. queuueue. queueueueueueue? | def enqueue(self, func, *args):
self.queue.append((func, args)) | [
"def add_job(self, func, *args, **kargs):\n self.work_queue.put((func, args, kargs))",
"def add(self, tube=None, func=None, data=None, timeout=120):\r\n if self.queue is None:\r\n log.warning(\"Attempted to add task, but task queue is not running.\")\r\n return\r\n \... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Pop off the top function from the internal queueuueue and then call it. God I REALLY hate queue. | def _dequeue(self):
func, args = self.queue.poplet()
func(*args) | [
"def unlock(self):\r\n if self.queue:\r\n function, argument = self.queue.popleft()\r\n function(argument)\r\n else:\r\n self.locked = False",
"def call_popped(self, call, head):\n pass",
"def __dequeue(self):\n return self.__queue.pop()",
"def pop_call... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
If exclusive is True the game will capture the mouse movement. If false, ignore the mouse. | def set_exclusive_mouse(self, exclusive):
super(Window, self).set_exclusive_mouse(exclusive)
self.exclusive = exclusive | [
"def mouseIsLocked(self):\n return False",
"def unlockMouse(self):\n pass",
"def mouse_entered(self):\n return False",
"def set_exclusive(self, exclusive):\n self.widget.SetExclusive(exclusive)",
"def player_handle_move(self) -> None:\r\n mouse_pos = pg.mouse.get_pos()\r\n... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Private implementation of the update() method this is the home of the motion logic, gravity, and collision detection. Dr. Strange, are you in there? | def _update(self, dt):
# Walking vvv
speed = FLYING_SPEED if self.flying else WALKING_SPEED
d = dt * speed # distance covered in that CPU tick
dx, dy, dz = self.get_motion_vector()
# New position in the space - prior to checking gravity method
dx, dy, dz = dx * d, dy *... | [
"def updatePhysics(self):",
"def physics_update(self) -> None:\n if not self.stopped:\n self.velocity += helpers.V(magnitude=self.gravity_power, angle=180)",
"def update(self):\n if self.moving_right and self.rect.right < self.screen_rect.right:\n self.centerx += self.setting... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Config OpenGL to draw in 2d | def set_2d(self):
width, height = self.get_size() # 1
glDisable(GL_DEPTH_TEST)
glViewport(0, 0, width, height)
glMatrixMode(GL_PROJECTION)
glLoadIdentity() # Clark Kent (?)
glOrtho(0, width, 0, height, -1, 1)
glMatrixMode(GL_MODELVIEW)
glLoadIdentity() | [
"def _conf_2d_env(self):\n gl.glViewport(0, 0, self._wx_size.width, self._wx_size.height)\n gl.glMatrixMode(gl.GL_PROJECTION)\n gl.glLoadIdentity()\n gl.glOrtho(0.0, self._wx_size.width,\n 0.0, self._wx_size.height,\n 0.0, 1.0)\n gl.glMatrixMode... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
get_observation_fields() work as expected (basic use) | def test_get_observation_fields(requests_mock):
requests_mock.get(
f'{API_V0}/observation_fields.json?q=sex',
json=SAMPLE_DATA['get_observation_fields_page2'],
status_code=200,
)
response = get_observation_fields(q='sex', page=2)
first_result = response['results'][0]
assert ... | [
"def load_observed_fields(self):\n try:\n fields = self.FieldType.load_database()\n except Exception as e:\n logging.warn(\"Failed to load completed exposures from database\")\n logging.info(e)\n fields = self.FieldType()\n self.observed_fields = fiel... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Return True if any service run by rMake requires ssl certificates | def requiresSsl(self):
if not self.isExternalRepos() and self.reposRequiresSsl():
return True
if not self.isExternalProxy() and self.proxyRequiresSsl():
return True
for uri in self.getServerUris():
if uri.startswith('https://'):
return True
... | [
"def _sanityCheckForSSL(self):\n if not self.requiresSsl():\n return 0\n\n if not self.sslCertPath:\n log.error(\"sslCertPath to be set - cannot start server\")\n return 1\n try:\n util.mkdirChain(os.path.dirname(self.sslCertPath))\n except OSE... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Check SSL settings, create SSL certificate if missing. Returns 0 if everything is OK, or an exit code otherwise | def _sanityCheckForSSL(self):
if not self.requiresSsl():
return 0
if not self.sslCertPath:
log.error("sslCertPath to be set - cannot start server")
return 1
try:
util.mkdirChain(os.path.dirname(self.sslCertPath))
except OSError, err:
... | [
"def ssl_check():\n return \"All ok, mm'kay.\"",
"def allow_self_signed_certificate():\n\n try:\n _create_unverified_https_context = ssl._create_unverified_context\n ssl._create_default_https_context = _create_unverified_https_context\n except AttributeError:\n # legacy Python that d... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Copy updateable options from a newly reloaded config | def updateFromReloaded(self, newCfg, log):
newCfg.sanityCheck()
newCfg.sanityCheckForStart()
for option in self.keys():
if self[option] == newCfg[option]:
continue
if option not in self._reloadable:
if log:
log.warning("... | [
"def copy_config():\n if options[\"mode\"] != \"personality\":\n copy_remote_config()",
"def CopyConfig(config):\n import copy\n config1 = copy.copy(config)\n \n # Make sure the input_manager isn't in the copy\n if 'input_manager' in config1:\n del config1['input_manager']\n\n # N... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |