query stringlengths 9 9.05k | document stringlengths 10 222k | negatives listlengths 19 20 | metadata dict |
|---|---|---|---|
A view to add a new portfolio project | def add_project(request):
if not request.user.is_superuser:
messages.error(request, 'Sorry, only store owners can do that.')
return redirect(reverse('home'))
if request.method == 'POST':
form = ProjectForm(request.POST, request.FILES)
if form.is_valid():
project = fo... | [
"def add_project():\n if request.method == \"POST\":\n result = add_project_to_db(\n request.form[\"title\"],\n request.form[\"link\"],\n request.form[\"description\"]\n )\n flash(result)\n return redirect(url_for(\"portfolio\"))\n else:\n re... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
A view to edit a portfolio project | def edit_project(request, project_id):
if not request.user.is_superuser:
messages.error(request, 'Sorry, only store owners can do that.')
return redirect(reverse('home'))
project = get_object_or_404(Project, pk=project_id)
if request.method == 'POST':
form = ProjectForm(request.POST... | [
"def project_edit(request, project_slug):\n project = get_object_or_404(request.user.projects.live(), slug=project_slug)\n\n if project.is_imported:\n form_class = ImportProjectForm\n else:\n form_class = CreateProjectForm\n\n form = form_class(instance=project, data=request.POST or None)\... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
A view to delete a project from the portfolio | def delete_project(request, project_id):
if not request.user.is_superuser:
messages.error(request, 'Sorry, only store owners can do that.')
return redirect(reverse('home'))
project = get_object_or_404(Project, pk=project_id)
project.delete()
messages.success(request, 'Project deleted!')... | [
"def delete_project(request, project):\n\n project = get_object_or_404(Project, id=project, user=request.user)\n if request.method == \"POST\":\n project.delete()\n return redirect(\"/projects/\")\n return render(request, \"delete-project.html\", {\"project\": project})",
"def delete_projec... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Find a single database | def find_database(self, name_or_id, instance, ignore_missing=True):
instance = self._get_resource(_instance.Instance, instance)
return self._find(
_database.Database,
name_or_id,
instance_id=instance.id,
ignore_missing=ignore_missing,
) | [
"def get_database(self, name):\n try:\n return [db for db in self.list_databases()\n if db.name == name][0]\n except IndexError:\n raise exc.NoSuchDatabase(\"No database by the name '%s' exists.\" %\n name)",
"def database():\n return _d... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Get a single database | def get_database(self, database, instance=None):
return self._get(_database.Database, database) | [
"def database():\n return _databases[_active_db]",
"def get_db(self, dbname, **params):\n return Database(self._db_uri(dbname), server=self, **params)",
"def select_db(cli, dbname):\n db = cli[dbname]\n return db",
"def get_database(self, name):\n try:\n return [db for db in ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Get a single flavor | def get_flavor(self, flavor):
return self._get(_flavor.Flavor, flavor) | [
"def get(self, flavor):\n return self._get(\"/flavors/%s\" % base.getid(flavor), \"flavor\")",
"def get_flavor(name):\r\n return nova.flavors.find(name=name)",
"def flavor(self, name=None):\n return self.find(self.flavors(), name=name)",
"def get_flavor(self, flavor_id):\n return self.... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Return a generator of flavors | def flavors(self, **query):
return self._list(_flavor.Flavor, **query) | [
"def flavors(self, details=True):\n flv = _flavor.FlavorDetail if details else _flavor.Flavor\n return list(self._list(flv, paginated=True))",
"def show_flavors():\n return get_flavors()",
"def describe_flavors(self):\r\n print(\"\\nFlavors of ice cream: \")\r\n for flavor in self... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Find a single instance | def find_instance(self, name_or_id, ignore_missing=True):
return self._find(
_instance.Instance, name_or_id, ignore_missing=ignore_missing
) | [
"def find_instance(cls, identifier):\r\n for instance in cls.all:\r\n if instance.identifier == identifier:\r\n return instance\r\n return None",
"def get_instance_by_name(self, name):\n try:\n data = self.get_instances()\n if \"errors\" in data... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Get a single instance | def get_instance(self, instance):
return self._get(_instance.Instance, instance) | [
"def _get_instance(self, id):\n if id not in self._instances:\n self._instances[id] = self._load_constructor(id)\n\n return self._instances[id]",
"def instance(cls):\n if cls._instance is None:\n cls._instance = cls()\n return cls._instance",
"def get(cls):\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Add a user to 'prospects' unless the user is the campaign owner or is already linked to 'workers', 'prospects', or 'blacklist'. Also decline to add prospects when the campaign is not active. user A TcsUser instance to link to 'prospects' | def addProspect(self, user):
if self.is_active and (user != self.owner) and not self.prospects.filter(pk=user.id).exists() \
and not self.workers.filter(pk=user.id) and not self.blacklist.filter(pk=user.id).exists():
self.prospects.add(user)
return self
return Non... | [
"def addWorker(self, user):\n if (user != self.owner) and not self.workers.filter(pk=user.id).exists():\n self.workers.add(user)\n if self.prospects.filter(pk=user.id).exists():\n self.prospects.remove(user)\n if self.blacklist.filter(pk=user.id).exists():\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Remove the user from the lists of workers and prospects, if applicable, and add the user to the blacklist. Note that adding somebody as a worker removes the person from the blacklist. user A TcsUser instance to link to the blacklist | def addToBlacklist(self, user):
if (user != self.owner) and not self.blacklist.filter(pk=user.id).exists():
self.blacklist.add(user)
if self.prospects.filter(pk=user.id).exists():
self.prospects.remove(user)
if self.workers.filter(pk=user.id).exists():
... | [
"async def blacklist(\n self, ctx: commands.Context, user: Union[ConvertUserAPI, discord.Member] = None\n ):\n if user is None:\n return await ctx.send_help()\n\n guild = ctx.guild\n async with self.config.guild(guild).blacklist() as data:\n if user.id not in dat... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Remove the user from 'prospects' and 'blacklist', if applicable, and add the user to 'workers'. Note that adding somebody as a worker removes the person from the blacklist. user A TcsUser instance to link to workers | def addWorker(self, user):
if (user != self.owner) and not self.workers.filter(pk=user.id).exists():
self.workers.add(user)
if self.prospects.filter(pk=user.id).exists():
self.prospects.remove(user)
if self.blacklist.filter(pk=user.id).exists():
... | [
"def addToBlacklist(self, user):\n if (user != self.owner) and not self.blacklist.filter(pk=user.id).exists():\n self.blacklist.add(user)\n if self.prospects.filter(pk=user.id).exists():\n self.prospects.remove(user)\n if self.workers.filter(pk=user.id).exists(... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Return active constituent voters who have not been contacted since the last election and have not been served to a supporter in the last two days. Don't limit the size of the result set here; let APIs do that. | def getVotersToContact(self):
two_days_ago = date.today() - timedelta(2)
year_ago = date.today() - timedelta(365)
return self.voters.filter(
Q(campaignstovoters__last_served=None) | Q(campaignstovoters__last_served__lt=two_days_ago),
Q(campaignstovoters__last_contacted=No... | [
"def get_past_incidents(self):\n return Incident.objects.filter(services__in=self,\n end_date__lte=datetime.now())",
"def _inactiveplayers():\n\n rosters = _activerosters()\n dbrosters = _eidset() # players not in rosters scrape but in db.\n notactive = dbros... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Return active constituent voters with valid phone contact information who have not been contacted since the last election. Don't limit the size of the result set here; let APIs do that. | def getVotersToDial(self):
return self.getVotersToContact().exclude(
(Q(phone_number1='') | Q(wrong_phone_number1__gt=1)),
(Q(phone_number2='') | Q(wrong_phone_number2__gt=1))) | [
"def getVotersToContact(self):\n two_days_ago = date.today() - timedelta(2)\n year_ago = date.today() - timedelta(365)\n return self.voters.filter(\n Q(campaignstovoters__last_served=None) | Q(campaignstovoters__last_served__lt=two_days_ago),\n Q(campaignstovoters__last_co... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Remove the user from 'workers' or 'prospects', if applicable. user A TcsUser instance to remove from workers | def removeWorker(self, user):
if user == self.owner:
return None
# Without these queries, there's no way to tell if anything actually gets removed.
# Calling remove() on a user that is not in the set does not raise an error.
if self.workers.filter(pk=user.id).exists():
... | [
"def addWorker(self, user):\n if (user != self.owner) and not self.workers.filter(pk=user.id).exists():\n self.workers.add(user)\n if self.prospects.filter(pk=user.id).exists():\n self.prospects.remove(user)\n if self.blacklist.filter(pk=user.id).exists():\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Return the number of voters a user has contacted for the campaign. | def voterContactCount(self, user):
return self.votercontact_set.filter(user=user).count() | [
"def number_of_volunteers(self):\n return self._number_of_volunteers",
"def get_number_of_ver_sponsors(model):\n n_agents = len([k for k, v in model.schedule.agents_by_type['Customer'].items() if v.__class__.__name__ == 'VerificationSponsor'])\n return n_agents",
"def nay_voter_cnt(self):\n\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Returns an indented representation of the nested dictionary. | def pretty_repr(self, num_spaces=4):
def pretty_dict(x):
if not isinstance(x, dict):
return repr(x)
rep = ''
for key, val in x.items():
rep += f'{key}: {pretty_dict(val)},\n'
if rep:
return '{\n' + _indent(rep, num_spaces) + '}'
else:
return '{}'
r... | [
"def _format_dict(self, dict_, indent=0):\n prefix = indent*\" \"*4\n output = \"{\\n\"\n for key, val in sorted(dict_.items()):\n if isinstance(val, dict):\n rval = self._format_dict(val, indent+1)\n else:\n rval = repr(val)\n outp... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Create a new FrozenDict with additional or replaced entries. | def copy(
self, add_or_replace: Mapping[K, V] = MappingProxyType({})
) -> 'FrozenDict[K, V]':
return type(self)({**self, **unfreeze(add_or_replace)}) # type: ignore[arg-type] | [
"def fromkeys(iterable, value=None):\n return FrozenDict(dict.fromkeys(iterable, value))",
"def copy(\n x: Union[FrozenDict, Dict[str, Any]],\n add_or_replace: Union[FrozenDict[str, Any], Dict[str, Any]] = FrozenDict(\n {}\n ),\n) -> Union[FrozenDict, Dict[str, Any]]:\n\n if isinstance(x, ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Deep copy unfrozen dicts to make the dictionary FrozenDict safe. | def _prepare_freeze(xs: Any) -> Any:
if isinstance(xs, FrozenDict):
# we can safely ref share the internal state of a FrozenDict
# because it is immutable.
return xs._dict # pylint: disable=protected-access
if not isinstance(xs, dict):
# return a leaf as is.
return xs
# recursively copy dicti... | [
"def unfreeze(x: Union[FrozenDict, Dict[str, Any]]) -> Dict[Any, Any]:\n if isinstance(x, FrozenDict):\n # deep copy internal state of a FrozenDict\n # the dict branch would also work here but\n # it is much less performant because jax.tree_util.tree_map\n # uses an optimized C implementation.\n ret... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Unfreeze a FrozenDict. Makes a mutable copy of a `FrozenDict` mutable by transforming it into (nested) dict. | def unfreeze(x: Union[FrozenDict, Dict[str, Any]]) -> Dict[Any, Any]:
if isinstance(x, FrozenDict):
# deep copy internal state of a FrozenDict
# the dict branch would also work here but
# it is much less performant because jax.tree_util.tree_map
# uses an optimized C implementation.
return jax.tre... | [
"def _prepare_freeze(xs: Any) -> Any:\n if isinstance(xs, FrozenDict):\n # we can safely ref share the internal state of a FrozenDict\n # because it is immutable.\n return xs._dict # pylint: disable=protected-access\n if not isinstance(xs, dict):\n # return a leaf as is.\n return xs\n # recursive... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Create a new dict with additional and/or replaced entries. This is a utility function that can act on either a FrozenDict or regular dict and mimics the behavior of `FrozenDict.copy`. | def copy(
x: Union[FrozenDict, Dict[str, Any]],
add_or_replace: Union[FrozenDict[str, Any], Dict[str, Any]] = FrozenDict(
{}
),
) -> Union[FrozenDict, Dict[str, Any]]:
if isinstance(x, FrozenDict):
return x.copy(add_or_replace)
elif isinstance(x, dict):
new_dict = jax.tree_map(lambda x:... | [
"def copy(\n self, add_or_replace: Mapping[K, V] = MappingProxyType({})\n ) -> 'FrozenDict[K, V]':\n return type(self)({**self, **unfreeze(add_or_replace)}) # type: ignore[arg-type]",
"def _prepare_freeze(xs: Any) -> Any:\n if isinstance(xs, FrozenDict):\n # we can safely ref share the internal stat... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Create a new dict where one entry is removed. This is a utility function that can act on either a FrozenDict or regular dict and mimics the behavior of `FrozenDict.pop`. | def pop(
x: Union[FrozenDict, Dict[str, Any]], key: str
) -> Tuple[Union[FrozenDict, Dict[str, Any]], Any]:
if isinstance(x, FrozenDict):
return x.pop(key)
elif isinstance(x, dict):
new_dict = jax.tree_map(lambda x: x, x) # make a deep copy of dict x
value = new_dict.pop(key)
return new_dict, ... | [
"def dictRemove(d, e):\n if e in d:\n d.pop(e)",
"def unfreeze(x: Union[FrozenDict, Dict[str, Any]]) -> Dict[Any, Any]:\n if isinstance(x, FrozenDict):\n # deep copy internal state of a FrozenDict\n # the dict branch would also work here but\n # it is much less performant because jax.tree_util... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Returns an indented representation of the nested dictionary. This is a utility function that can act on either a FrozenDict or regular dict and mimics the behavior of `FrozenDict.pretty_repr`. If x is any other dtype, this function will return `repr(x)`. | def pretty_repr(x: Any, num_spaces: int = 4) -> str:
if isinstance(x, FrozenDict):
return x.pretty_repr()
else:
def pretty_dict(x):
if not isinstance(x, dict):
return repr(x)
rep = ''
for key, val in x.items():
rep += f'{key}: {pretty_dict(val)},\n'
if rep:
... | [
"def pretty_repr(self, num_spaces=4):\n\n def pretty_dict(x):\n if not isinstance(x, dict):\n return repr(x)\n rep = ''\n for key, val in x.items():\n rep += f'{key}: {pretty_dict(val)},\\n'\n if rep:\n return '{\\n' + _indent(rep, num_spaces) + '}'\n else:\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Load a subset of the COCO dataset. | def load_coco(self, dataset_dir, subset, year=DEFAULT_DATASET_YEAR, class_ids=None, class_names=None,
class_map=None, return_coco=False, auto_download=False):
if auto_download is True:
self.auto_download(dataset_dir, subset, year)
coco = COCO("{}/annotations/instances_{}{... | [
"def load_coco(self, dataset_dir, subset, year=DEFAULT_DATASET_YEAR, class_ids=None,\n class_map=None, return_coco=False):\n\n coco = COCO(\"{}/annotations/instances_{}{}.json\".format(dataset_dir, subset, year))\n if subset == \"minival\" or subset == \"valminusminival\":\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Updates this store's current state with incoming data from the network. data should be a mapping containing 'metacontacts', 'order', and 'info' structures (see comment at top of file) | def update_data(self, data):
rebuild = False
# This method needs to substitute some defaultdicts for the normal
# dictionaries that come back from the server.
# Metacontact information
#if data['metacontacts']
mc_dict = data.get('metacontacts', {})
if... | [
"def update(self, data):\n\n\t\tself.data = data\n\t\tself.last_update = time.time()",
"def update_data():\n pass",
"def set_observed_data(self, data):\n self.state_space.data = data",
"def update_data(self):\n pass",
"def _update_model(self, new_state, data):",
"def _update_data(self... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Error in label only whitespace allowed, no tabs if checked label differs, raise an error | def CheckLabel(Line):
for i in Line:
if i == '\t': #can't detect leading tabs, stops at the first \
raise InputError(Line,"malformed input")
elif i != ' ':
break | [
"def test_label(self):\n nt = NewickTokenizer(newick=\"(a\\n'b',(b,c),(d,e));\")\n self.assertRaises(ValueError, nt.tokens)",
"def test_ignoring_label_to_string(self):\n code = \"\"\"nop\n label:\n nop\"\"\"\n interpreter = Interpreter(code)\n i... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
parsing a given text file containing labels and sequences load file, tidy it, process each line in the file return the labels and sequences as list[tuple(string,string)] | def ParseSeqFile(FilePath):
SeqFile = rSeqFile(FilePath)
TidyFile = TidyLines(SeqFile)
result = []
for line in TidyFile:
t = ( ProcessLine(line) )
result.append(t)
return(result) | [
"def parse(self):\n\n with open(self.fasta_file) as file:\n content = file.readlines()\n\n sequences = []\n sequence_ids = []\n sequence = []\n for line in content:\n if line.startswith('>'):\n sequence_ids.append(line.strip())\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Return 'p1' if the current player is Player 1, and 'p2' if the current player is Player 2. | def get_current_player_name(self) -> str:
if self.p1_turn:
return 'p1'
return 'p2' | [
"def opponent(self):\n if self.player() == 'p1':\n return 'p2'\n else:\n return 'p1'",
"def other_player(player):\n if player == PLAYER_ONE:\n return PLAYER_TWO\n elif player == PLAYER_TWO:\n return PLAYER_ONE\n else:\n retu... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Return whether move is a valid move for this GameState. | def is_valid_move(self, move: Any) -> bool:
return move in self.get_possible_moves() | [
"def has_valid_move(self) -> bool:\r\n\t\tis_valid_move = False\r\n\t\tfor row in range(self._othello_game.get_rows()):\r\n\t\t\tif is_valid_move:\r\n\t\t\t\tbreak\r\n\r\n\t\t\tfor col in range(self._othello_game.get_cols()):\r\n\r\n\t\t\t\tif len(self._othello_game.placement_is_valid(row, col)) > 0: #if the move i... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Return an estimate in interval [LOSE, WIN] of best outcome the current player can guarantee from state self. | def rough_outcome(self) -> float:
# HUYNH YOU PRICK WHY THE FUCK DO YOU MAKE US WRITE THIS SHIT EVEN IT'S NOT USED ANYWHERE
# pick move based on this may not be optimal but better than random
# return 1 if win immediately
# return -1 if all states reachable will result the other player w... | [
"def rough_outcome(self) -> float:\n if is_win(self):\n return 1\n elif is_lose(self):\n return -1\n return 0",
"def rough_outcome_strategy(game: 'Game') -> Any:\n current_state = game.current_state\n best_move = None\n best_outcome = -2 # Temporarily -- just so... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Set common fields in layer to addressing dictonary. | def set_address_values(layer):
cursor = arcpy.SearchCursor(layer)
for row in cursor:
layer_fields = arcpy.ListFields(layer)
for x in range(len(layer_fields)):
layer_fields[x] = layer_fields[x].name
for key in address_dict:
if key in layer_fields and address_dict.g... | [
"def _update_layer_fields(layer, field_mapping):\r\n\r\n if 'layerDefinition' in layer and layer['layerDefinition'] is not None:\r\n layer_definition = layer['layerDefinition']\r\n \r\n if 'definitionExpression' in layer_definition and layer_definition['definitionExpression'] is not None... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Get AWS ECS task information. For the puspose of getting the EC2 instance id by a given AWS ECS task name, for now, only the 'containerInstanceArn' is fetched from the AWS ECS task. | def get_tasks_information(
task: str,
list_tasks: str,
cluster=CLUSTER_NAME,
client=None,
region=REGION,
):
if not client:
session = boto3.session.Session()
client = session.client("ecs", region)
try:
# Get all tasks in the cluster.
cluster_tasks = client.list... | [
"def get(profile, cluster, tasks):\n client = boto3client.get(\"ecs\", profile)\n params = {}\n params[\"cluster\"] = cluster\n params[\"tasks\"] = tasks\n return client.describe_tasks(**params)",
"def get_ec2_instances(self, task):\n # Assemble arguments to filter ec2 instances by task and ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Geeft bericht of iemand lang genoeg is voor de attractie. | def lang_genoeg(lengte):
return | [
"def substituer(texte): # Donne une vague idée mais pas efficace, mal codé\r\n alphabet = \"abcdefghijklmnopqrstuvwxyz\"\r\n texte_lettre_only = []\r\n for car in texte:\r\n if car in alphabet:\r\n texte_lettre_only.append(car)\r\n nouveau_texte = list(texte)\r\n j = 0\r\n alpha... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Add a Pseudocode Operation at the actual active buffer. | def AddPseudoCode(self, pcode):
self.buffers[self.buffergrade].append(pcode) | [
"def add_code(self, code):\n self.code += code",
"def add_operation(self):\n arg1 = self.memory[self.memory[self._cursor + 1]]\n arg2 = self.memory[self.memory[self._cursor + 2]]\n arg3 = self.memory[self._cursor + 3]\n self.memory[arg3] = arg1 + arg2\n # print(f'Cursor: ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Increment the BufferGrade and initialize a new empty buffer. | def IndentBuffer(self):
self.buffergrade += 1
self.buffers[self.buffergrade] = [] | [
"def set_garbage(self):\n self.grade = 0",
"def new_grade(self, value):\r\n self.logger.warn(\"Setting values on new_grade will NOT update the remote Canvas instance.\")\r\n self._new_grade = value",
"def update(self, grade):\n for i, component_grade in enumerate(grade._component_gra... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Decrement the BufferGrade and pop out the buffer active before. | def DeIndentBuffer(self):
if self.buffergrade == 0:
raise Exception("You can't deindent more.")
self.buffergrade -= 1
tmp = self.buffers[self.buffergrade + 1]
del self.buffers[self.buffergrade + 1]
return tmp | [
"def decrease_grade(self):\n if self.grade > 0:\n self.grade -= 1",
"def decrease(self):\n self.score -= self.score",
"def hit_decrement(self):\n self.hit -= 1",
"def decrement(self):\n self.count -= 1",
"def decrement(self):\n self.data[self.pointer] -= 1\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Get a reference to the actual buffer activated. | def RefBuffer(self):
return self.buffers[self.buffergrade] | [
"def buffer(self):\n return self.buffer_dict.get_active()",
"def get_buffer(self):\n return self.buffer",
"def current_buffer(self):\n return self.layout.current_buffer",
"def buffer_backend(cls, *args, **kwargs):\n return cls._buffer_context",
"def current_buffer_app(self):\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Track a code indentation index for successive utilization. | def TrackIfIndex(self, index):
self.indentindex.append(index) | [
"def increase_code_indent(self) -> None:\n self._parent_node.increase_code_indent()",
"def _increaseindentation(self):\n self._indentlist.append(self._curindent)\n if not self._equalsigns[-1]:\n self._curindent = self._curindent + self._indent",
"def addIndent(self):\r\n s... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Pop (get and remove) the last code indentation index tracked. | def PopIfIndex(self):
return self.indentindex.pop() | [
"def _decreaseindentation(self):\n self._curindent = self._indentlist.pop()",
"def pop(self, i=0):\n return self.frame.stack.pop(-1-i)",
"def pop_scope(self):\n top = self.scope_stack[-1]\n self.scope_stack = self.scope_stack[:-1]\n return top",
"def pop_current_line(self):\... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Initialization of protected Operation Object attribute for subclasses. | def __init__(self):
self._OPERATION = None | [
"def __init__(self, **kwargs):\n super(StoredObject, self).__init__()",
"def __init__(self):\n Calculation.__init__(self)\n\n self._calculation_process_type = BasicCalculationProcess",
"def __init__(self, operations = []):\n self.operations = operations",
"def __init__(self):\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Get the Operation Object generated by the command. | def getOp(self):
return self._OPERATION | [
"def get_operation(self) -> Operation:\n\n if self.operation_type == 'model':\n operation = Model(operation_type=self.operation_name)\n elif self.operation_type == 'data_operation':\n operation = DataOperation(operation_type=self.operation_name)\n else:\n raise ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Creates a temporary image for manipulation, and handles optional RGB conversion. | def _create_tmp_image(self, content):
content.seek(0)
image = Image.open(content)
if self.force_rgb and image.mode not in ('L', 'RGB', 'RGBA'):
image = image.convert('RGB')
return image | [
"def temporary_image(self):\n\n image = Image.new('RGB', (1, 1))\n tmp_file = tempfile.NamedTemporaryFile(suffix='.jpg')\n image.save(tmp_file, 'jpeg')\n # important because after save(),\n # the fp is already at the end of the file\n tmp_file.seek(0) # retrieves the creat... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Renders the image. Override this method when creating a custom renderer. | def _render(self, image):
raise NotImplementedError('Override this method to render images!') | [
"def render_canvas(self):\r\n self._display.image(self._image)\r\n self._display.display()",
"def render(self):\n self.dirty = True\n self.image.fill(self.fill_color)\n if len(self.text):\n while self.font.size(self.text)[0]> self.pixel_width:\n self.ba... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Normalize, pad and batch the input images. | def preprocess_image(self, batched_inputs):
images = [x.to(self.device) for x in batched_inputs]
norms = [self.normalizer(x) for x in images]
size = (norms[0].shape[1],norms[0].shape[2])
images = ImageList.from_tensors(norms, self.backbone.size_divisibility)
return images, size | [
"def normalize_images(data, blend_cat, Args):\n im = data['X_train']['blend_image']\n std = np.std(im)\n mean = np.mean(im)\n data['X_train']['blend_image'] = (im - mean) / std\n data['X_val']['blend_image'] = (data['X_val']['blend_image'] - mean) / std\n data['X_train'] = normalize_other_inputs(d... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Ensure that apigateway v1 and apigateway v2 actions are both present in the ses namespace | def test_services_with_multiple_pages_apigateway(self):
# API Gateway Management V1: https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonapigatewaymanagement.html
self.assertTrue("apigateway:AddCertificateToDomain" in self.all_actions)
self.assertTrue("apigateway:Remove... | [
"def test_gh_226_elasticloadbalancing_v1_and_v2(self):\n results = get_actions_for_service(\"elasticloadbalancing\")\n # print(json.dumps(results, indent=4))\n lb_v1_only_action = \"elasticloadbalancing:CreateTargetGroup\"\n lb_v2_only_action = \"elasticloadbalancing:SetSecurityGroups\"\... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Ensure that awsmarketplace actions from all the different awsmarketplace SAR pages are present in the IAM definition. | def test_services_with_multiple_pages_aws_marketplace(self):
# Overlap: AWS Marketplace, Marketplace Catalog, and AWS Marketplace Entitlement service, AWS Marketplace Image Building Service, AWS Marketplace Metering Service, AWS Marketplace Private Marketplace, and AWS Marketplace Procurement Systems
# ... | [
"def test_get_actions_with_arn_type_and_access_level_case_3(self):\n desired_output = [\n 's3:PutAccountPublicAccessBlock',\n 's3:PutAccessPointPublicAccessBlock'\n ]\n output = get_actions_with_arn_type_and_access_level(\n # \"ram\", \"resource-share\", \"Write... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Ensure that greengrass v1 and greengrass v2 actions are both present in the greengrass namespace | def test_services_with_multiple_pages_greengrass(self):
# Greengrass V1: https://docs.aws.amazon.com/service-authorization/latest/reference/list_awsiotgreengrass.html
self.assertTrue("greengrass:CreateResourceDefinition" in self.all_actions)
# Greengrass V2: https://docs.aws.amazon.com/service-a... | [
"def test_gh_226_elasticloadbalancing_v1_and_v2(self):\n results = get_actions_for_service(\"elasticloadbalancing\")\n # print(json.dumps(results, indent=4))\n lb_v1_only_action = \"elasticloadbalancing:CreateTargetGroup\"\n lb_v2_only_action = \"elasticloadbalancing:SetSecurityGroups\"\... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Ensure that elb v1 and elb v2 actions are both present in the elasticloadbalancing namespace | def test_services_with_multiple_pages_elb(self):
results = get_actions_for_service("elasticloadbalancing")
actions = [
"elasticloadbalancing:ApplySecurityGroupsToLoadBalancer",
"elasticloadbalancing:AttachLoadBalancerToSubnets",
"elasticloadbalancing:ConfigureHealthCh... | [
"def test_gh_226_elasticloadbalancing_v1_and_v2(self):\n results = get_actions_for_service(\"elasticloadbalancing\")\n # print(json.dumps(results, indent=4))\n lb_v1_only_action = \"elasticloadbalancing:CreateTargetGroup\"\n lb_v2_only_action = \"elasticloadbalancing:SetSecurityGroups\"\... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Ensure that lex v1 and lex v2 actions are both present in the lex namespace | def test_services_with_multiple_pages_lex(self):
# Lex V1: https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonlex.html
self.assertTrue("lex:DeleteUtterances" in self.all_actions)
# Lex V2: https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonle... | [
"def test_kafka_action_names_overlap_issue(self):\n # Kafka actions used to be in two pages but are now one. This verifies the current state.\n # results = get_actions_for_service(\"kafka\")\n # print(results)\n actions = [\n \"kafka:BatchAssociateScramSecret\",\n \... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Ensure that Kinesis Analytics V1 actions are both present in the ses namespace | def test_services_with_multiple_pages_kinesis_analytics(self):
# Kinesis Analytics V1
results = get_actions_for_service("kinesisanalytics")
actions = [
"kinesisanalytics:GetApplicationState", # Only in v1, not v2
"kinesisanalytics:ListApplications", # In both
]
... | [
"def test_kafka_action_names_overlap_issue(self):\n # Kafka actions used to be in two pages but are now one. This verifies the current state.\n # results = get_actions_for_service(\"kafka\")\n # print(results)\n actions = [\n \"kafka:BatchAssociateScramSecret\",\n \... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Ensure that ses v1 and ses v2 actions are both present in the ses namespace | def test_services_with_multiple_pages_ses(self):
# SES V1: https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonses.html
self.assertTrue("ses:PutIdentityPolicy" in self.all_actions)
# SES V2: https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazons... | [
"def test_gh_226_elasticloadbalancing_v1_and_v2(self):\n results = get_actions_for_service(\"elasticloadbalancing\")\n # print(json.dumps(results, indent=4))\n lb_v1_only_action = \"elasticloadbalancing:CreateTargetGroup\"\n lb_v2_only_action = \"elasticloadbalancing:SetSecurityGroups\"\... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Ensure that kafka actions are not overwritten in the IAM definition | def test_kafka_action_names_overlap_issue(self):
# Kafka actions used to be in two pages but are now one. This verifies the current state.
# results = get_actions_for_service("kafka")
# print(results)
actions = [
"kafka:BatchAssociateScramSecret",
"kafka:BatchDisa... | [
"def test_excluded_actions_scan_policy_file(self):\n test_policy = {\n \"Version\": \"2012-10-17\",\n \"Statement\": [\n {\n \"Effect\": \"Allow\",\n \"Action\": [\n \"s3:GetObject\",\n \"... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
1. Maintain a decreasing stack by scanning nums from left to right. 2. Then scan the nums from right to left and calculate the maxWidth between each ramp. | def maxWidthRamp(self, nums: list[int]) -> int:
maxWidth = 0
descStack = []
# Generate decreasing stack.
for i, num in enumerate(nums):
if not descStack or nums[descStack[-1]] > num:
descStack.append(i)
# Check elements from right to left.
fo... | [
"def peg_width_per_levels(base_width):\n limiter = 2\n decrementer = -2\n decrementing_width = int(base_width)\n peg_count_per_level = []\n while decrementing_width >= limiter:\n peg_count_per_level.append(int(decrementing_width))\n decrementing_width += decrementer\n return peg_coun... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Given an input (instance of the BenchInput tuple), constructs and validates a disjunctive ChaumPedersen proof, returning the time (in seconds) to do each operation. | def chaum_pedersen_bench(bi: BenchInput) -> Tuple[float, float]:
(keypair, r, s) = bi
ciphertext = get_optional(elgamal_encrypt(0, r, keypair.public_key))
start1 = timer()
proof = make_disjunctive_chaum_pedersen_zero(
ciphertext, r, keypair.public_key, ONE_MOD_Q, s
)
end1 = timer()
v... | [
"def dpTime():\n print \"calculating...\"\n startTime = time.time()\n dpa = dpAdvisor(subjects, 20)\n endTime = time.time()\n #printSubjects(dpa)\n print \"%.4f\" % (endTime-startTime)",
"def dpTime():\n start_time = time.time()\n subjects = loadSubjects(SUBJECT_FILENAME)\n maxWork = 50... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Test of function choosing if log rotation is needed | def test_need_to_rotate_log(self):
self.assertTrue(need_to_rotate_log(0, 20, 'daily', 15, 'daily'), 'rotate log by time')
self.assertFalse(need_to_rotate_log(10, 20, 'daily', 15, 'hourly'), 'do not rotate log by time')
self.assertTrue(need_to_rotate_log(10, 20, 'daily', 25, None), 'rotate log by... | [
"def _should_rotate_log(self, handler):\n if handler[\"rotate_log\"]:\n rotate_time_index = handler.get(\"rotate_log_index\", \"day\")\n try:\n rotate_time_index = self._decode_time_rotation_index(rotate_time_index)\n except ValueError:\n rotate_... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Tests of try rotation with compress in configuration | def test_process_log_with_compress_in_configuration(self):
with tempfile.TemporaryDirectory() as sandbox:
with mock.patch('sys.stdout', new=io.StringIO()) as fake_stdout:
srcfile = Path(sandbox, 'pokus.log')
srcfile.touch()
destfile = Path(sandbox, 'ba... | [
"def test_compress_works(self):\n tau = 45.0\n mrate = 60.0\n Mrate = 100.0\n gain = 5\n\n tmax = 50.0\n dt = 0.2\n\n self.rule.tau = tau\n self.rule.min_rate = mrate\n self.rule.max_rate = Mrate\n self.rule.compress_rates = False\n self.rule.gain = gain\n\n self.motor.error_fct ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Test get_spec_config on empty conf | def test_get_spec_config_empty(self):
spec_conf = get_spec_config({}, '')
self.assertEqual(spec_conf, {}) | [
"def test_get_spec_config_defaults(self):\n spec_conf = get_spec_config({\n 'defaults': {\n 'foo': 'bar'\n }\n }, '')\n self.assertEqual(spec_conf, {'foo': 'bar'})",
"def test_get_missing_param(self):\n Config.init(sample_conf)\n res = Config... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Test get_spec_config on conf with defaults | def test_get_spec_config_defaults(self):
spec_conf = get_spec_config({
'defaults': {
'foo': 'bar'
}
}, '')
self.assertEqual(spec_conf, {'foo': 'bar'}) | [
"def test_get_spec_config_match(self):\n spec_conf = get_spec_config({\n 'defaults': {\n 'default_foo': 'default_bar',\n 'foo': 'bar'\n },\n 'specific': [\n {'mask': ['filenomatch'], 'foo': 'bar_nomatch'},\n {'mask':... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Test get_spec_config on matching conf | def test_get_spec_config_match(self):
spec_conf = get_spec_config({
'defaults': {
'default_foo': 'default_bar',
'foo': 'bar'
},
'specific': [
{'mask': ['filenomatch'], 'foo': 'bar_nomatch'},
{'mask': ['filematch'... | [
"def test_get_canary_configs_using_get(self):\n pass",
"def test_get_canary_config_using_get(self):\n pass",
"def test_get_spec_config_defaults(self):\n spec_conf = get_spec_config({\n 'defaults': {\n 'foo': 'bar'\n }\n }, '')\n self.assert... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Check that given modifier name is valid one. If not raise exception based on violation. | def _isValidModifier(self, modifiers, modifierName):
if Modifiers.ILLEGAL_MODIFIER_PATTER.search(modifierName):
msg = ('Modifier named "{0}" in sheet {1} contains illegal characters. '
'Supported characters are a to z, A to Z, 0 to 9 and underscore "_". '
'Space... | [
"def validate_name(name, reserved_names=()):",
"def check_name(name):\n if len(name) > WorkflowCRD.NAME_MAX_LENGTH:\n raise ValueError(\n \"Name is too long. Max length: {}, now: {}\"\n \"\".format(WorkflowCRD.NAME_MAX_LENGTH, len(name))\n )\n if \... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Determines if a given datetime.datetime is aware. | def is_aware(value):
return value.tzinfo is not None and value.tzinfo.utcoffset(value) is not None | [
"def is_aware(value: datetime) -> bool:\n\n return value.utcoffset() is not None",
"def dt_is_aware(dtime):\n if dtime.tzinfo is not None and dtime.tzinfo.utcoffset(dtime) is not None:\n return True\n\n return False",
"def dt_is_aware(dt_value):\n return dt_value.tzinfo is not None and dt_val... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Define ZMQ connection and return socket to work with | def connect_to_worker():
socket = context.socket(zmq.REQ)
socket.connect("tcp://localhost:5555")
return socket | [
"def get_connection(self):\n\n # Socket type DEALER is used in asynchronous request/reply patterns.\n # It prepends identity of the socket with each message.\n socket = self.zmq_context.socket(zmq.DEALER)\n socket.setsockopt(zmq.IDENTITY, self.identity)\n socket.connect('tcp://127... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Used to handle not responding zmq server | def raise_timeout(*args, **kwargs):
raise ZMQNotResponding('ZMQ server is not responding') | [
"def fix_zmq_exit():\n import zmq\n ctx = zmq.Context.instance()\n ctx.term()",
"def test_recv_nomsg(self):\n flag, msg_recv = self.recv_instance.recv(timeout=self.sleeptime)\n assert(not flag)\n nt.assert_equal(msg_recv, self.recv_instance.eof_msg)",
"def checkConnection(self,msg)... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
this functions creates a draft with the email data given the user id should be either 'me', either 'users/email.com' either 'users/{AAD_userId}', | def create_draft(auth, subject, body, addresses, user_id, cc_addresses=[], attachments_list=None):
data = {}
data['Subject'] = subject
data['Body'] = {}
data['Body']['ContentType'] = 'HTML'
data['Body']['Content'] = body
data['ToRecipients'] = [{'EmailAddress': {'Address': addr}} for addr ... | [
"def create_draft(self, subject=\"\", to=\"\", cc=\"\", bcc=\"\", content=\"\", draft_folder=None):\n \n new_message = self._create_message_wrapper(subject, to, cc, bcc, content)\n \n if not self.is_simulate:\n try:\n if draft_folder is not None:\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
iterator which goes through all the pages to find all the emails | def get_all_emails_it(auth, user_id, folder_id='AllItems', pages_limit=None, pages_size=50, **kwargs):
i = 0
args_dict = dict(kwargs, top=pages_size, skip=pages_size * i)
curr_emails = get_emails(auth, user_id, folder_id, **args_dict)
while len(curr_emails) != 0:
yield curr_emails
... | [
"def test_get_inbox_emails_paginated(self):\n pass",
"def get_email_addresses(startdate, enddate, user, password):\n emails = []\n page = 1\n more_pages = True\n\n while more_pages:\n response = requests.get(\n 'https://restapi.surveygizmo.com/v2/survey/{survey}'\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Calculate the masked ratio. | def get_masked_ratio(mask):
hist = mask.histogram()
return hist[0] / np.prod(mask.size) | [
"def maskedFraction(self):\n\n\t\tif not self._masked:\n\t\t\treturn 0.0\n\t\telse:\n\t\t\treturn self._masked_fraction",
"def adv_ratio(self): # XXX\r\n bw = StatsRouter.global_bw_mean\r\n if bw == 0.0: return 0\r\n else: return self.bw/bw",
"def mask_percent(img):\n if (len(img.shape) == 3) and (i... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Create a dictionary with domain architectures exclusive in a single pathogen type group. | def generateArchitectureDataStructure(db, collapse_pathogen_groups=False):
# Calculate total numbers of species and strains for each pathogen group
counts_species_pathogen_dict = defaultdict(lambda: defaultdict(int))
for row in db.getNumSpeciesPathogen():
counts_species_pathogen_dict[row['pathogen_... | [
"def get_architectures() -> dict:\n archs = {}\n for arch in list(Architecture):\n archs[arch.name] = arch\n\n return archs",
"def for_sim_type(sim_type):\n if sim_type not in cfg:\n return {}\n return pkcollections.map_to_dict(cfg[sim_type])",
"def formDomain(self):\r\n doma... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Boolean function to check if a given architecture is exclusive. | def exclusive_arch(pathogen_groups_set, collapse_pathogen_groups):
if len(pathogen_groups_set) == 1:
return True
# Only check pathogen grouping when the flag is on
if collapse_pathogen_groups:
if len(pathogen_groups_set) > 2:
return False
if 0 in pathogen_groups_set and ... | [
"def IsExclusive(self):\n return False",
"def isCheckedOutExclusive(self) -> bool:\n ...",
"def exclusive_state(self) -> bool:\n return pulumi.get(self, \"exclusive_state\")",
"def is_skip_and_return_zero_patch_available(\n\t self, addr: int, arch: Optional['architecture.Architecture'] = N... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
returns True if employee has rejoined otherwise False | def is_rejoinee(self):
return len(self._start_date) > 1 | [
"def is_employee():\n return _is_member('uw_employee')",
"def is_expired(self):\n expiration_date = datetime.timedelta(days=settings.ACCOUNT_ACTIVATION_DAYS)\n return (self.date_joined + expiration_date <= datetime.datetime.now())",
"def already_booked(slots, attendees, user_name):\n already... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Process the Exit of employee | def process_employee_exit(self):
if self.is_employee_serving():
self._end_date.append(datetime.now().isoformat())
print(f"Successfully processed exit for employee {self.name} on" \
f"{self._end_date[-1]}\nWe wish {self.name} for future endeavours")
retu... | [
"def identify_result_exit(self, record):\n return [\"exit\"]",
"def _handler_generic_exit(self):",
"def _common_state_exit(self, *args, **kwargs):",
"def _exit(n):\n pass",
"def exit(self, status=0,message=None):\n\t\tpass",
"def on_exit_step(self) -> Event:\n return self._on_exit_step",
... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Takes a full media url from Bandwidth and extracts the media id | def get_media_id(media_url):
split_url = media_url.split("/")
#Media urls of the format https://messaging.bandwidth.com/api/v2/users/123/media/file.png
if split_url[-2] == "media":
return split_url[-1]
#Media urls of the format https://messaging.bandwidth.com/api/v2/users/123/media/abc/0/file.pn... | [
"def extract_media_id(self, s):\n return int(re.findall(r\"_(\\d+).ts\", s)[0])",
"def _id_from_url(url):\n url = re.sub(r'\\?.*', '', url)\n video_id = url.split('/')[-2]\n return video_id",
"def parse_media_id(request: Request) -> Tuple[str, str, Optional[str]]:\n try:\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Takes a full media url from Bandwidth and extracts the filename | def get_media_filename(media_url):
return media_url.split("/")[-1] | [
"def get_content_name(self, content_url):\n endpoint = content_url.split('/')[-1]\n return re.match(r'(.+\\.(?:jpg|mp4))', endpoint).group(0)",
"def getImageFilename(url):\n head, filename = url.rsplit('/', 1)\n return filename",
"def get_media_id(media_url):\n split_url = media_url.split... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Takes a list of media urls and downloads the media into the temporary storage | def download_media_from_bandwidth(media_urls):
downloaded_media_files = []
for media_url in media_urls:
media_id = get_media_id(media_url)
filename = get_media_filename(media_url)
with open(filename, "wb") as f:
try:
downloaded_media = messaging_client.get_med... | [
"def download_all_media():\n # download_path = '{}'.format(os.path.join(folder_name(conv_s()), \"media\"))\n # profile.set_preference(\"browser.download.dir\", download_path)\n open_media()\n download_media()\n while left_media():\n pass\n esc()\n esc()\n o(\"Finished downloading medi... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Takes a list of media files and uploads them to Bandwidth The media file names are used as the media id | def upload_media_to_bandwidth(media_files):
for filename in media_files:
with open(filename, "rb") as f:
file_content = f.read()
try:
##Note: The filename is doubling as the media id##
response = messaging_client.upload_media(MESSAGING_ACCOUNT_ID, file... | [
"def _upload(self, files, voice_clip=False):\n file_dict = {\"upload_{}\".format(i): f for i, f in enumerate(files)}\n\n data = {\"voice_clip\": voice_clip}\n\n j = self._payload_post(\n \"https://upload.facebook.com/ajax/mercury/upload.php\", data, files=file_dict\n )\n\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Removes all of the given files | def remove_files(files):
for file_name in files:
os.remove(file_name) | [
"def remove_files(self, files: Set[str]) -> None:\n for f in files:\n src = os.path.join(self.get_directory(), f)\n os.remove(src)",
"def remove_files(self):\n for ff in self._all_paths:\n try:\n os.remove(ff)\n except OSError:\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Takes information from a Bandwidth inbound message callback that includes media and responds with a text message containing the same media sent through Bandwidth's media resource. | def handle_inbound_media_mms(to, from_, media):
downloaded_media_files = download_media_from_bandwidth(media)
upload_media_to_bandwidth(downloaded_media_files)
remove_files(downloaded_media_files)
body = MessageRequest()
body.application_id = MESSAGING_APPLICATION_ID
body.to = [from_]
body.m... | [
"def send_callback(context):\n publish_next_media_to_channel(context, chat_id=context.job.context)",
"def handle_inbound_message():\n data = json.loads(request.data)\n\n if data[0][\"type\"] == \"message-received\":\n if \"call me\" in data[0][\"message\"][\"text\"]:\n handle_inbound_sm... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Takes information from a Bandwidth inbound message callback and initiates a call | def handle_inbound_sms_call_me(to, from_):
handle_call_me(to, from_) | [
"def incoming_call(self, call):\n self.active_call = call\n self.ringer.play_ringer()",
"def _handleMessage(self):\r\n call = self._onBeforeCall()\r\n ## execute incoming RPC\r\n d = maybeDeferred(self._callProcedure, call)\r\n ## register callback and errback with extra argument... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
A method for showing how to handle Bandwidth messaging callbacks. For inbound SMS that contains the phrase "call me", a phone call is made and the user is asked to forward the call to another number For inbound SMS that doesn't contain the phrase "call me", the response is a SMS with the date and time. For inbound MMS ... | def handle_inbound_message():
data = json.loads(request.data)
if data[0]["type"] == "message-received":
if "call me" in data[0]["message"]["text"]:
handle_inbound_sms_call_me(data[0]["message"]["to"][0], data[0]["message"]["from"])
elif "media" in data[0]["message"]:
han... | [
"def handle_inbound_sms_call_me(to, from_):\n handle_call_me(to, from_)",
"def handleSMS(self, callerID, message, node):",
"def handle_inbound_media_mms(to, from_, media):\n downloaded_media_files = download_media_from_bandwidth(media)\n upload_media_to_bandwidth(downloaded_media_files)\n remove_fil... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Formats |record| with color. | def format(self, record):
msg = super(ColoredFormatter, self).format(record)
color = self._COLOR_MAPPING.get(record.levelname)
if self._use_colors and color:
msg = '%s%s%s' % (color, msg, self._RESET)
return msg | [
"def format(self, record):\n\t\tif self.color:\n\t\t\ttry:\n\t\t\t\tcat = getattr(record, self.CATEGORY, None)\n\t\t\t\tif not cat:\n\t\t\t\t\tif record.levelname == 'WARN': cat = LOG_WARN\n\t\t\t\t\telif record.levelname == 'ERROR': cat = LOG_ERROR\n\t\t\t\t\telif record.levelname == 'DEBUG': cat = LOG_DEBUG\n\t\t... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Always symlink |path| to a relativized |target|. | def symlink(target, path):
unlink(path)
path = os.path.realpath(path)
target = os.path.relpath(os.path.realpath(target), os.path.dirname(path))
logging.info('Symlinking %s -> %s', path, target)
os.symlink(target, path) | [
"def symlink(self, path, target, *args, **kwargs): # pragma: no cover",
"def symlink_to(self, target, target_is_directory=False):\n if self._closed:\n self._raise_closed()\n self._accessor.symlink(target, self, target_is_directory)",
"def symlink(source, link_name, target_is_directory=... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Return sha256 hex digest of |path|. | def sha256(path: Union[Path, str]) -> str:
# The file shouldn't be too big to load into memory, so be lazy.
with open(path, 'rb') as fp:
data = fp.read()
m = hashlib.sha256()
m.update(data)
return m.hexdigest() | [
"def hex_hash(path):\n\n return hashlib.md5(path).hexdigest()[:2]",
"def hexhash(path):\n\n m = hashlib.md5()\n with open(path) as handle:\n for line in handle:\n m.update(line)\n return m.hexdigest()",
"def _checksum_sha256(file_path):\n sha256_hash = hashlib.sha256()\n chunk_... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Unpack |archive| into |cwd|. | def unpack(archive: Union[Path, str],
cwd: Optional[Path] = None,
files: Optional[List[Union[Path, str]]] = ()):
archive = Path(archive)
if cwd is None:
cwd = Path.cwd()
if files:
files = ['--'] + list(files)
else:
files = []
# Try to make symlink usage... | [
"def unpack_archive(fname: Union[str, Path], tgt_dir: Union[str, Path]) -> None:\n shutil.unpack_archive(str(fname), str(tgt_dir))",
"def _unzip(archive, dst):\n with zipfile.ZipFile(archive) as zf:\n for zi in zf.infolist():\n if zi.filename[-1] == '/': # skip dir\n contin... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Create an |archive| with |paths| in |cwd|. The output will use XZ compression. | def pack(archive: Union[Path, str],
paths: List[Union[Path, str]],
cwd: Optional[Path] = None,
exclude: Optional[List[Union[Path, str]]] = ()):
archive = Path(archive)
if cwd is None:
cwd = Path.cwd()
if archive.suffix == '.xz':
archive = archive.with_suffix('')
... | [
"def make_archive():\n Utils.delete_if_exist(Path.get_zip_path(True))\n shutil.make_archive(Path.get_zip_path(), 'zip', Utils.reverse_path_if_windows(Path.get_dist_path()))",
"def generate_archive_file(location, paths, environment=None, compression=None, archive_format=None):\n if archive_format == 'zip'... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Fetch |uri| and write the results to |output| (or return BytesIO). | def fetch_data(uri: str, output=None, verbose: bool = False, b64: bool = False):
# This is the timeout used on each blocking operation, not the entire
# life of the connection. So it's used for initial urlopen and for each
# read attempt (which may be partial reads). 5 minutes should be fine.
TIMEOUT ... | [
"def _fetch_file(self, location, output=None):\n\n self.log.debug(\"Fetching '%s' file...\" % location)\n\n if not output:\n output = tempfile.mktemp(\"-dogen\")\n\n self.log.debug(\"Fetched file will be saved as '%s'...\" % os.path.basename(output))\n\n r = requests.get(locat... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Download our copies of node & npm to our tree and updates env ($PATH). | def node_and_npm_setup():
# We have to update modules first as it'll nuke the dir node lives under.
node.modules_update()
node.update() | [
"def InstallNodeDependencies():\n logging.info('entering ...')\n # Install the project dependencies specified in package.json into\n # node_modules.\n logging.info('installing AMP Validator engine dependencies ...')\n subprocess.check_call(\n ['npm', 'install', '--userconfig', '../.npmrc'],\n stdout=... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Load a module from the filesystem. | def load_module(name, path):
loader = importlib.machinery.SourceFileLoader(name, path)
module = types.ModuleType(loader.name)
loader.exec_module(module)
return module | [
"def load_module(name, path):\n\n spec = importlib.util.spec_from_file_location(name, path)\n module = importlib.util.module_from_spec(spec)\n spec.loader.exec_module(module)\n return module",
"def loadModule (\r\n \r\n self,\r\n path = None\r\n ) :\r\n\r\n if not ut... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Load & cache the program module. | def _module(self):
if self._module_cache is None:
self._module_cache = load_module(self._name, self._path)
return self._module_cache | [
"def load(self):\n \"\"\"Load a program into memory.\"\"\"\n\n if len(sys.argv) != 2:\n print(\"format: ls8.py [filename]\")\n sys.exit(1)\n\n program = sys.argv[1]\n address = 0\n\n # For now, we've just hardcoded a program:\n\n # program = [\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Set the packet length. | def _set_packet_len(self, packet_len):
self._packet_len = packet_len | [
"def setPacketLength(self):\n self.packetLength = len(self) - PRIMARY_HEADER_BYTE_SIZE - 1",
"def setlen(self, length):\n self._len = length",
"def set_length(self, length):\n self.length = length",
"def set(self, length):\r\n self.length = length",
"def setLength(self, new_length):\... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Creates a XCP Ethernet frame | def create_message(self, packet):
self._header.packet_len = len(bytes(packet))
frame_bytes = super(EthernetTransport, self).create_message(packet)
# Update control counter for next frame
self._header.update_control()
return bytes(frame_bytes) | [
"def _create_frame(self, packets, type):\n fr = bytearray()\n fr += struct.pack('>H', type.value)\n fr += struct.pack('>H', len(packets))\n frameno = self.next_frameno()\n fr += struct.pack('>Q', frameno)\n for pkt in packets:\n fr += struct.pack('>H', len(pkt))\... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Computes the pickup_features feature group. To restrict features to a time range, pass in ts_column, start_date, and/or end_date as kwargs. | def pickup_features_fn(df, ts_column, start_date, end_date):
df = filter_df_by_ts(
df, ts_column, start_date, end_date
)
pickupzip_features = (
df.groupBy(
"pickup_zip", window("tpep_pickup_datetime", "1 hour", "15 minutes")
) # 1 hour window, sliding every 15 minutes
... | [
"def dropoff_features_fn(df, ts_column, start_date, end_date):\n df = filter_df_by_ts(\n df, ts_column, start_date, end_date\n )\n dropoffzip_features = (\n df.groupBy(\"dropoff_zip\", window(\"tpep_dropoff_datetime\", \"30 minute\"))\n .agg(count(\"*\").alias(\"count_trips_window_30m... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Computes the dropoff_features feature group. To restrict features to a time range, pass in ts_column, start_date, and/or end_date as kwargs. | def dropoff_features_fn(df, ts_column, start_date, end_date):
df = filter_df_by_ts(
df, ts_column, start_date, end_date
)
dropoffzip_features = (
df.groupBy("dropoff_zip", window("tpep_dropoff_datetime", "30 minute"))
.agg(count("*").alias("count_trips_window_30m_dropoff_zip"))
... | [
"def pickup_features_fn(df, ts_column, start_date, end_date):\n df = filter_df_by_ts(\n df, ts_column, start_date, end_date\n )\n pickupzip_features = (\n df.groupBy(\n \"pickup_zip\", window(\"tpep_pickup_datetime\", \"1 hour\", \"15 minutes\")\n ) # 1 hour window, sliding... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Ceilings datetime dt to interval num_minutes, then returns the unix timestamp. | def rounded_unix_timestamp(dt, num_minutes=15):
nsecs = dt.minute * 60 + dt.second + dt.microsecond * 1e-6
delta = math.ceil(nsecs / (60 * num_minutes)) * (60 * num_minutes) - nsecs
return int((dt + timedelta(seconds=delta)).timestamp()) | [
"def dt_to_unix_time_ms(cls, dt):\n epoch = datetime.utcfromtimestamp(0)\n return int((dt - epoch).total_seconds() * 1000)",
"def _time_ms(dt):\n epoch = datetime.datetime.utcfromtimestamp(0)\n diff = dt - epoch\n return diff.total_seconds() * 1000",
"def to_min(dt: datetime) -> int:\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Return current sample rate in Sa/s | def sample_rate(self):
return self.query_float('ENTER Current Sample Rate (Sa/s)') | [
"def sample_rate(self) -> float:\n return self._sample_rate",
"def sample_rate(self):\r\n return self.config.sample_rate",
"def get_sample_rate(self):\n time_diffs = np.diff(self.get_time()).mean()\n return 1000/time_diffs",
"def sampling_rate(self):\n return self.librarycal... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
assert unexpected_content has not been written to stdout | def assertStdoutDoesNotContain(self, unexpected_content):
if type(unexpected_content) is not types.ListType:
unexpected_content = [ unexpected_content ]
stdout_message = sys.stdout.getvalue()
for the_text in unexpected_content:
self.assertNotIn(the_text, stdout_message,('... | [
"def check_cot_output(self, expected):\n sys.stdout = StringIO.StringIO()\n output = None\n try:\n self.instance.run()\n except (TypeError, ValueError, SyntaxError, LookupError):\n self.fail(traceback.format_exc())\n finally:\n output = sys.stdout.... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Render the image represented by (rgbobj) at dst_x, dst_y in the offscreen pixmap. | def render_image(self, rgbobj, dst_x, dst_y):
self.logger.debug("redraw pixmap=%s" % (self.pixmap))
if self.pixmap is None:
return
self.logger.debug("drawing to pixmap")
# Prepare array for rendering
arr = rgbobj.get_array(self.rgb_order, dtype=np.uint8)
(hei... | [
"def draw(self, surface):\r\n surface.blit(self.image, self.rect)",
"def blit(self):\n self.screen.blit(self.image, self.rect)",
"def draw_image_processing(self, screen):\n screen.blit(self.get_image_processing(), self.get_image_processing_rect())",
"def draw_inkblot(self):\n self.... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Called when a mouse button is pressed in the widget. Adjust method signature as appropriate for callback. | def button_press_event(self, widget, event):
x, y = event.x, event.y
# x, y = coordinates where the button was pressed
self.last_win_x, self.last_win_y = x, y
button = 0
# Prepare a button mask with bits set as follows:
# left button: 0x1
# middle button: ... | [
"def on_mouse_press(self, x, y, button):\n\n pass",
"def mouse_press(self, btn, x, y, modifiers):",
"def on_mouse_press(self, x, y, button, modifiers):\n pass",
"def _press(self, event):",
"def on_mouse_release(self, x, y, button):\n pass",
"def onMousePressed(self, event):\n (... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Called when a drop (drag/drop) event happens in the widget. Adjust method signature as appropriate for callback. | def drop_event(self, widget, event):
# make a call back with a list of URLs that were dropped
#self.logger.debug("dropped filename(s): %s" % (str(paths)))
#self.make_ui_callback('drag-drop', paths)
raise NotImplementedError | [
"def hook_drop(self):\n widget = self.widget\n widget.setAcceptDrops(True)\n widget.dragEnterEvent = self.dragEnterEvent\n widget.dragMoveEvent = self.dragMoveEvent\n widget.dragLeaveEvent = self.dragLeaveEvent\n widget.dropEvent = self.dropEvent",
"def dropEvent(self, e)... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Gets details on currently logged in athlete. | def get_athlete(token):
url = "https://www.strava.com/api/v3/athlete"
params = {'access_token': token}
response = return_json(url, "GET", parameters=params, timeout=10)
return response | [
"def set_athlete(response):\n name = response['athlete']['firstname'] + \" \" + response['athlete']['lastname']\n athlete = {\n 'id': response['athlete']['id'],\n 'name': name,\n 'access_token': response['access_token'],\n 'refresh_to... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Stores athlete's id, first name, last name, weight and ftp into strava_athlete KV Store collection. | def kvstore_save_athlete(session_key, athlete_id, firstname, lastname, weight, ftp): # pylint: disable=too-many-arguments
url = 'https://localhost:8089/servicesNS/nobody/TA-strava-for-splunk/storage/collections/data/strava_athlete/batch_save'
headers = {'Content-Type': 'application/json', 'Auth... | [
"def set_athlete(response):\n name = response['athlete']['firstname'] + \" \" + response['athlete']['lastname']\n athlete = {\n 'id': response['athlete']['id'],\n 'name': name,\n 'access_token': response['access_token'],\n 'refresh_to... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Creates dict with athlete details, including token expiry. | def set_athlete(response):
name = response['athlete']['firstname'] + " " + response['athlete']['lastname']
athlete = {
'id': response['athlete']['id'],
'name': name,
'access_token': response['access_token'],
'refresh_token': respons... | [
"def get_athlete(token):\n url = \"https://www.strava.com/api/v3/athlete\"\n params = {'access_token': token}\n response = return_json(url, \"GET\", parameters=params, timeout=10)\n return response",
"def alpaca_create(self, keyname = \"ALPACA_API_KEY\", secret = \"ALPA... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |