text_prompt
stringlengths 100
17.7k
⌀ | code_prompt
stringlengths 7
9.86k
⌀ |
|---|---|
<SYSTEM_TASK:>
Import a module with an optional yaml config file, but only if we haven't
<END_TASK>
<USER_TASK:>
Description:
def module_cache_get(cache, module):
"""
Import a module with an optional yaml config file, but only if we haven't
imported it already.
:param cache: object which holds information on which modules and config
files have been loaded and whether config files should be
loaded.
:param module: the path of the module to load.
:returns: the loaded module.
""" |
if getattr(cache, "config", False):
config_file = module[:-2] + "yaml"
if config_file not in cache.config_files and os.path.exists(config_file):
try:
config = yaml_safe_load(config_file, type=dict)
except TypeError as e:
tangelo.log_warning("TANGELO", "Bad configuration in file %s: %s" % (config_file, e))
raise
except IOError:
tangelo.log_warning("TANGELO", "Could not open config file %s" % (config_file))
raise
except ValueError as e:
tangelo.log_warning("TANGELO", "Error reading config file %s: %s" % (config_file, e))
raise
cache.config_files[config_file] = True
else:
config = {}
cherrypy.config["module-config"][module] = config
cherrypy.config["module-store"].setdefault(module, {})
# If two threads are importing the same module nearly concurrently, we
# could load it twice unless we use the import lock.
imp.acquire_lock()
try:
if module not in cache.modules:
name = module[:-3]
# load the module.
service = imp.load_source(name, module)
cache.modules[module] = service
else:
service = cache.modules[module]
finally:
imp.release_lock()
return service |
<SYSTEM_TASK:>
Flush data, write 28 bytes BGZF EOF marker, and close BGZF file.
<END_TASK>
<USER_TASK:>
Description:
def close(self):
"""Flush data, write 28 bytes BGZF EOF marker, and close BGZF file.
samtools will look for a magic EOF marker, just a 28 byte empty BGZF
block, and if it is missing warns the BAM file may be truncated. In
addition to samtools writing this block, so too does bgzip - so this
implementation does too.
""" |
if self._buffer:
self.flush()
self._handle.write(_bgzf_eof)
self._handle.flush()
self._handle.close() |
<SYSTEM_TASK:>
Check if secret key to encryot sessions exists,
<END_TASK>
<USER_TASK:>
Description:
def ensure_secret():
"""Check if secret key to encryot sessions exists,
generate it otherwise.""" |
home_dir = os.environ['HOME']
file_name = home_dir + "/.ipcamweb"
if os.path.exists(file_name):
with open(file_name, "r") as s_file:
secret = s_file.readline()
else:
secret = os.urandom(24)
with open(file_name, "w") as s_file:
secret = s_file.write(secret+"\n")
return secret |
<SYSTEM_TASK:>
Returns a list of screenshots
<END_TASK>
<USER_TASK:>
Description:
def list_snapshots_for_a_minute(path, cam_id, day, hourm):
"""Returns a list of screenshots""" |
screenshoots_path = path+"/"+str(cam_id)+"/"+day+"/"+hourm
if os.path.exists(screenshoots_path):
screenshots = [scr for scr in sorted(os.listdir(screenshoots_path))]
return screenshots
else:
return [] |
<SYSTEM_TASK:>
Return affected start position in 0-based coordinates
<END_TASK>
<USER_TASK:>
Description:
def affected_start(self):
"""Return affected start position in 0-based coordinates
For SNVs, MNVs, and deletions, the behaviour is the start position.
In the case of insertions, the position behind the insert position is
returned, yielding a 0-length interval together with
:py:meth:`~Record.affected_end`
""" |
types = {alt.type for alt in self.ALT} # set!
BAD_MIX = {INS, SV, BND, SYMBOLIC} # don't mix well with others
if (BAD_MIX & types) and len(types) == 1 and list(types)[0] == INS:
# Only insertions, return 0-based position right of first base
return self.POS # right of first base
else: # Return 0-based start position of first REF base
return self.POS - 1 |
<SYSTEM_TASK:>
Add label to FILTER if not set yet, removing ``PASS`` entry if
<END_TASK>
<USER_TASK:>
Description:
def add_filter(self, label):
"""Add label to FILTER if not set yet, removing ``PASS`` entry if
present
""" |
if label not in self.FILTER:
if "PASS" in self.FILTER:
self.FILTER = [f for f in self.FILTER if f != "PASS"]
self.FILTER.append(label) |
<SYSTEM_TASK:>
Add an entry to format
<END_TASK>
<USER_TASK:>
Description:
def add_format(self, key, value=None):
"""Add an entry to format
The record's calls ``data[key]`` will be set to ``value`` if not yet
set and value is not ``None``. If key is already in FORMAT then
nothing is done.
""" |
if key in self.FORMAT:
return
self.FORMAT.append(key)
if value is not None:
for call in self:
call.data.setdefault(key, value) |
<SYSTEM_TASK:>
Return ``True`` for filtered calls
<END_TASK>
<USER_TASK:>
Description:
def is_filtered(self, require=None, ignore=None):
"""Return ``True`` for filtered calls
:param iterable ignore: if set, the filters to ignore, make sure to
include 'PASS', when setting, default is ``['PASS']``
:param iterable require: if set, the filters to require for returning
``True``
""" |
ignore = ignore or ["PASS"]
if "FT" not in self.data or not self.data["FT"]:
return False
for ft in self.data["FT"]:
if ft in ignore:
continue # skip
if not require:
return True
elif ft in require:
return True
return False |
<SYSTEM_TASK:>
Split the ``str`` in ``pair_str`` at ``'='``
<END_TASK>
<USER_TASK:>
Description:
def split_mapping(pair_str):
"""Split the ``str`` in ``pair_str`` at ``'='``
Warn if key needs to be stripped
""" |
orig_key, value = pair_str.split("=", 1)
key = orig_key.strip()
if key != orig_key:
warnings.warn(
"Mapping key {} has leading or trailing space".format(repr(orig_key)),
LeadingTrailingSpaceInKey,
)
return key, value |
<SYSTEM_TASK:>
Parse the given VCF header line mapping
<END_TASK>
<USER_TASK:>
Description:
def parse_mapping(value):
"""Parse the given VCF header line mapping
Such a mapping consists of "key=value" pairs, separated by commas and
wrapped into angular brackets ("<...>"). Strings are usually quoted,
for certain known keys, exceptions are made, depending on the tag key.
this, however, only gets important when serializing.
:raises: :py:class:`vcfpy.exceptions.InvalidHeaderException` if
there was a problem parsing the file
""" |
if not value.startswith("<") or not value.endswith(">"):
raise exceptions.InvalidHeaderException(
"Header mapping value was not wrapped in angular brackets"
)
# split the comma-separated list into pairs, ignoring commas in quotes
pairs = split_quoted_string(value[1:-1], delim=",", quote='"')
# split these pairs into key/value pairs, converting flags to mappings
# to True
key_values = []
for pair in pairs:
if "=" in pair:
key, value = split_mapping(pair)
if value.startswith('"') and value.endswith('"'):
value = ast.literal_eval(value)
elif value.startswith("[") and value.endswith("]"):
value = [v.strip() for v in value[1:-1].split(",")]
else:
key, value = pair, True
key_values.append((key, value))
# return completely parsed mapping as OrderedDict
return OrderedDict(key_values) |
<SYSTEM_TASK:>
Return mapping for parsers to use for each VCF header type
<END_TASK>
<USER_TASK:>
Description:
def build_header_parsers():
"""Return mapping for parsers to use for each VCF header type
Inject the WarningHelper into the parsers.
""" |
result = {
"ALT": MappingHeaderLineParser(header.AltAlleleHeaderLine),
"contig": MappingHeaderLineParser(header.ContigHeaderLine),
"FILTER": MappingHeaderLineParser(header.FilterHeaderLine),
"FORMAT": MappingHeaderLineParser(header.FormatHeaderLine),
"INFO": MappingHeaderLineParser(header.InfoHeaderLine),
"META": MappingHeaderLineParser(header.MetaHeaderLine),
"PEDIGREE": MappingHeaderLineParser(header.PedigreeHeaderLine),
"SAMPLE": MappingHeaderLineParser(header.SampleHeaderLine),
"__default__": StupidHeaderLineParser(), # fallback
}
return result |
<SYSTEM_TASK:>
Convert atomic field value according to the type
<END_TASK>
<USER_TASK:>
Description:
def convert_field_value(type_, value):
"""Convert atomic field value according to the type""" |
if value == ".":
return None
elif type_ in ("Character", "String"):
if "%" in value:
for k, v in record.UNESCAPE_MAPPING:
value = value.replace(k, v)
return value
else:
try:
return _CONVERTERS[type_](value)
except ValueError:
warnings.warn(
("{} cannot be converted to {}, keeping as " "string.").format(value, type_),
CannotConvertValue,
)
return value |
<SYSTEM_TASK:>
Parse ``value`` according to ``field_info``
<END_TASK>
<USER_TASK:>
Description:
def parse_field_value(field_info, value):
"""Parse ``value`` according to ``field_info``
""" |
if field_info.id == "FT":
return [x for x in value.split(";") if x != "."]
elif field_info.type == "Flag":
return True
elif field_info.number == 1:
return convert_field_value(field_info.type, value)
else:
if value == ".":
return []
else:
return [convert_field_value(field_info.type, x) for x in value.split(",")] |
<SYSTEM_TASK:>
Parse breakend and return tuple with results, parameters for BreakEnd
<END_TASK>
<USER_TASK:>
Description:
def parse_breakend(alt_str):
"""Parse breakend and return tuple with results, parameters for BreakEnd
constructor
""" |
arr = BREAKEND_PATTERN.split(alt_str)
mate_chrom, mate_pos = arr[1].split(":", 1)
mate_pos = int(mate_pos)
if mate_chrom[0] == "<":
mate_chrom = mate_chrom[1:-1]
within_main_assembly = False
else:
within_main_assembly = True
FWD_REV = {True: record.FORWARD, False: record.REVERSE}
orientation = FWD_REV[alt_str[0] == "[" or alt_str[0] == "]"]
mate_orientation = FWD_REV["[" in alt_str]
if orientation == record.FORWARD:
sequence = arr[2]
else:
sequence = arr[0]
return (mate_chrom, mate_pos, orientation, mate_orientation, sequence, within_main_assembly) |
<SYSTEM_TASK:>
Process substution where the string grows
<END_TASK>
<USER_TASK:>
Description:
def process_sub_grow(ref, alt_str):
"""Process substution where the string grows""" |
if len(alt_str) == 0:
raise exceptions.InvalidRecordException("Invalid VCF, empty ALT")
elif len(alt_str) == 1:
if ref[0] == alt_str[0]:
return record.Substitution(record.DEL, alt_str)
else:
return record.Substitution(record.INDEL, alt_str)
else:
return record.Substitution(record.INDEL, alt_str) |
<SYSTEM_TASK:>
Process substution where the string shrink
<END_TASK>
<USER_TASK:>
Description:
def process_sub_shrink(ref, alt_str):
"""Process substution where the string shrink""" |
if len(ref) == 0:
raise exceptions.InvalidRecordException("Invalid VCF, empty REF")
elif len(ref) == 1:
if ref[0] == alt_str[0]:
return record.Substitution(record.INS, alt_str)
else:
return record.Substitution(record.INDEL, alt_str)
else:
return record.Substitution(record.INDEL, alt_str) |
<SYSTEM_TASK:>
Process alternative value using Header in ``header``
<END_TASK>
<USER_TASK:>
Description:
def process_alt(header, ref, alt_str): # pylint: disable=W0613
"""Process alternative value using Header in ``header``""" |
# By its nature, this function contains a large number of case distinctions
if "]" in alt_str or "[" in alt_str:
return record.BreakEnd(*parse_breakend(alt_str))
elif alt_str[0] == "." and len(alt_str) > 0:
return record.SingleBreakEnd(record.FORWARD, alt_str[1:])
elif alt_str[-1] == "." and len(alt_str) > 0:
return record.SingleBreakEnd(record.REVERSE, alt_str[:-1])
elif alt_str[0] == "<" and alt_str[-1] == ">":
inner = alt_str[1:-1]
return record.SymbolicAllele(inner)
else: # substitution
return process_sub(ref, alt_str) |
<SYSTEM_TASK:>
Split string ``s`` at delimiter, correctly interpreting quotes
<END_TASK>
<USER_TASK:>
Description:
def run(self, s):
"""Split string ``s`` at delimiter, correctly interpreting quotes
Further, interprets arrays wrapped in one level of ``[]``. No
recursive brackets are interpreted (as this would make the grammar
non-regular and currently this complexity is not needed). Currently,
quoting inside of braces is not supported either. This is just to
support the example from VCF v4.3.
""" |
begins, ends = [0], []
# transition table
DISPATCH = {
self.NORMAL: self._handle_normal,
self.QUOTED: self._handle_quoted,
self.ARRAY: self._handle_array,
self.DELIM: self._handle_delim,
self.ESCAPED: self._handle_escaped,
}
# run state automaton
state = self.NORMAL
for pos, c in enumerate(s):
state = DISPATCH[state](c, pos, begins, ends)
ends.append(len(s))
assert len(begins) == len(ends)
# Build resulting list
return [s[start:end] for start, end in zip(begins, ends)] |
<SYSTEM_TASK:>
Handle FORMAT and calls columns, factored out of parse_line
<END_TASK>
<USER_TASK:>
Description:
def _handle_calls(self, alts, format_, format_str, arr):
"""Handle FORMAT and calls columns, factored out of parse_line""" |
if format_str not in self._format_cache:
self._format_cache[format_str] = list(map(self.header.get_format_field_info, format_))
# per-sample calls
calls = []
for sample, raw_data in zip(self.samples.names, arr[9:]):
if self.samples.is_parsed(sample):
data = self._parse_calls_data(format_, self._format_cache[format_str], raw_data)
call = record.Call(sample, data)
self._format_checker.run(call, len(alts))
self._check_filters(call.data.get("FT"), "FORMAT/FT", call.sample)
calls.append(call)
else:
calls.append(record.UnparsedCall(sample, raw_data))
return calls |
<SYSTEM_TASK:>
Split line and check number of columns
<END_TASK>
<USER_TASK:>
Description:
def _split_line(self, line_str):
"""Split line and check number of columns""" |
arr = line_str.rstrip().split("\t")
if len(arr) != self.expected_fields:
raise exceptions.InvalidRecordException(
(
"The line contains an invalid number of fields. Was "
"{} but expected {}\n{}".format(len(arr), 9 + len(self.samples.names), line_str)
)
)
return arr |
<SYSTEM_TASK:>
Parse genotype call information from arrays using format array
<END_TASK>
<USER_TASK:>
Description:
def _parse_calls_data(klass, format_, infos, gt_str):
"""Parse genotype call information from arrays using format array
:param list format: List of strings with format names
:param gt_str arr: string with genotype information values
""" |
data = OrderedDict()
# The standard is very nice to parsers, we can simply split at
# colon characters, although I (Manuel) don't know how strict
# programs follow this
for key, info, value in zip(format_, infos, gt_str.split(":")):
data[key] = parse_field_value(info, value)
return data |
<SYSTEM_TASK:>
Check ``FORMAT`` of a record.Call
<END_TASK>
<USER_TASK:>
Description:
def run(self, call, num_alts):
"""Check ``FORMAT`` of a record.Call
Currently, only checks for consistent counts are implemented
""" |
for key, value in call.data.items():
self._check_count(call, key, value, num_alts) |
<SYSTEM_TASK:>
Read next line store in self._line and return old one
<END_TASK>
<USER_TASK:>
Description:
def _read_next_line(self):
"""Read next line store in self._line and return old one""" |
prev_line = self._line
self._line = self.stream.readline()
return prev_line |
<SYSTEM_TASK:>
Peform additional check on samples line
<END_TASK>
<USER_TASK:>
Description:
def _check_samples_line(klass, arr):
"""Peform additional check on samples line""" |
if len(arr) <= len(REQUIRE_NO_SAMPLE_HEADER):
if tuple(arr) != REQUIRE_NO_SAMPLE_HEADER:
raise exceptions.IncorrectVCFFormat(
"Sample header line indicates no sample but does not "
"equal required prefix {}".format("\t".join(REQUIRE_NO_SAMPLE_HEADER))
)
elif tuple(arr[: len(REQUIRE_SAMPLE_HEADER)]) != REQUIRE_SAMPLE_HEADER:
raise exceptions.IncorrectVCFFormat(
'Sample header line (starting with "#CHROM") does not '
"start with required prefix {}".format("\t".join(REQUIRE_SAMPLE_HEADER))
) |
<SYSTEM_TASK:>
Get a snapshot and save it to disk.
<END_TASK>
<USER_TASK:>
Description:
def snap(self, path=None):
"""Get a snapshot and save it to disk.""" |
if path is None:
path = "/tmp"
else:
path = path.rstrip("/")
day_dir = datetime.datetime.now().strftime("%d%m%Y")
hour_dir = datetime.datetime.now().strftime("%H%M")
ensure_snapshot_dir(path+"/"+self.cam_id+"/"+day_dir+"/"+hour_dir)
f_path = "{0}/{1}/{2}/{3}/{4}.jpg".format(
path,
self.cam_id,
day_dir,
hour_dir,
datetime.datetime.now().strftime("%S"),
)
urllib.urlretrieve(
'http://{0}/snapshot.cgi?user={1}&pwd={2}'.format(
self.address,
self.user,
self.pswd,
),
f_path,
) |
<SYSTEM_TASK:>
Jump to the start position of the given chromosomal position
<END_TASK>
<USER_TASK:>
Description:
def fetch(self, chrom_or_region, begin=None, end=None):
"""Jump to the start position of the given chromosomal position
and limit iteration to the end position
:param str chrom_or_region: name of the chromosome to jump to if
begin and end are given and a samtools region string otherwise
(e.g. "chr1:123,456-123,900").
:param int begin: 0-based begin position (inclusive)
:param int end: 0-based end position (exclusive)
""" |
if begin is not None and end is None:
raise ValueError("begin and end must both be None or neither")
# close tabix file if any and is open
if self.tabix_file and not self.tabix_file.closed:
self.tabix_file.close()
# open tabix file if not yet open
if not self.tabix_file or self.tabix_file.closed:
self.tabix_file = pysam.TabixFile(filename=self.path, index=self.tabix_path)
# jump to the next position
if begin is None:
self.tabix_iter = self.tabix_file.fetch(region=chrom_or_region)
else:
self.tabix_iter = self.tabix_file.fetch(reference=chrom_or_region, start=begin, end=end)
return self |
<SYSTEM_TASK:>
Close underlying stream
<END_TASK>
<USER_TASK:>
Description:
def close(self):
"""Close underlying stream""" |
if self.tabix_file and not self.tabix_file.closed:
self.tabix_file.close()
if self.stream:
self.stream.close() |
<SYSTEM_TASK:>
Serialize value for the given mapping key for a VCF header line
<END_TASK>
<USER_TASK:>
Description:
def serialize_for_header(key, value):
"""Serialize value for the given mapping key for a VCF header line""" |
if key in QUOTE_FIELDS:
return json.dumps(value)
elif isinstance(value, str):
if " " in value or "\t" in value:
return json.dumps(value)
else:
return value
elif isinstance(value, list):
return "[{}]".format(", ".join(value))
else:
return str(value) |
<SYSTEM_TASK:>
Build indices for the different field types
<END_TASK>
<USER_TASK:>
Description:
def _build_indices(self):
"""Build indices for the different field types""" |
result = {key: OrderedDict() for key in LINES_WITH_ID}
for line in self.lines:
if line.key in LINES_WITH_ID:
result.setdefault(line.key, OrderedDict())
if line.mapping["ID"] in result[line.key]:
warnings.warn(
("Seen {} header more than once: {}, using first" "occurence").format(
line.key, line.mapping["ID"]
),
DuplicateHeaderLineWarning,
)
else:
result[line.key][line.mapping["ID"]] = line
else:
result.setdefault(line.key, [])
result[line.key].append(line)
return result |
<SYSTEM_TASK:>
Return header lines having the given ``key`` as their type
<END_TASK>
<USER_TASK:>
Description:
def get_lines(self, key):
"""Return header lines having the given ``key`` as their type""" |
if key in self._indices:
return self._indices[key].values()
else:
return [] |
<SYSTEM_TASK:>
Return whether there is a header line with the given ID of the
<END_TASK>
<USER_TASK:>
Description:
def has_header_line(self, key, id_):
"""Return whether there is a header line with the given ID of the
type given by ``key``
:param key: The VCF header key/line type.
:param id_: The ID value to compare fore
:return: ``True`` if there is a header line starting with ``##${key}=``
in the VCF file having the mapping entry ``ID`` set to ``id_``.
""" |
if key not in self._indices:
return False
else:
return id_ in self._indices[key] |
<SYSTEM_TASK:>
Add header line, updating any necessary support indices
<END_TASK>
<USER_TASK:>
Description:
def add_line(self, header_line):
"""Add header line, updating any necessary support indices
:return: ``False`` on conflicting line and ``True`` otherwise
""" |
self.lines.append(header_line)
self._indices.setdefault(header_line.key, OrderedDict())
if not hasattr(header_line, "mapping"):
return False # no registration required
if self.has_header_line(header_line.key, header_line.mapping["ID"]):
warnings.warn(
(
"Detected duplicate header line with type {} and ID {}. "
"Ignoring this and subsequent one"
).format(header_line.key, header_line.mapping["ID"]),
DuplicateHeaderLineWarning,
)
return False
else:
self._indices[header_line.key][header_line.mapping["ID"]] = header_line
return True |
<SYSTEM_TASK:>
Create a switch.
<END_TASK>
<USER_TASK:>
Description:
def create_switch(type, settings, pin):
"""Create a switch.
Args:
type: (str): type of the switch [A,B,C,D]
settings (str): a comma separted list
pin (int): wiringPi pin
Returns:
switch
""" |
switch = None
if type == "A":
group, device = settings.split(",")
switch = pi_switch.RCSwitchA(group, device)
elif type == "B":
addr, channel = settings.split(",")
addr = int(addr)
channel = int(channel)
switch = pi_switch.RCSwitchB(addr, channel)
elif type == "C":
family, group, device = settings.split(",")
group = int(group)
device = int(device)
switch = pi_switch.RCSwitchC(family, group, device)
elif type == "D":
group, device = settings.split(",")
device = int(device)
switch = pi_switch.RCSwitchD(group, device)
else:
print "Type %s is not supported!" % type
sys.exit()
switch.enableTransmit(pin)
return switch |
<SYSTEM_TASK:>
Format atomic value
<END_TASK>
<USER_TASK:>
Description:
def format_atomic(value):
"""Format atomic value
This function also takes care of escaping the value in case one of the
reserved characters occurs in the value.
""" |
# Perform escaping
if isinstance(value, str):
if any(r in value for r in record.RESERVED_CHARS):
for k, v in record.ESCAPE_MAPPING:
value = value.replace(k, v)
# String-format the given value
if value is None:
return "."
else:
return str(value) |
<SYSTEM_TASK:>
Format possibly compound value given the FieldInfo
<END_TASK>
<USER_TASK:>
Description:
def format_value(field_info, value, section):
"""Format possibly compound value given the FieldInfo""" |
if section == "FORMAT" and field_info.id == "FT":
if not value:
return "."
elif isinstance(value, list):
return ";".join(map(format_atomic, value))
elif field_info.number == 1:
if value is None:
return "."
else:
return format_atomic(value)
else:
if not value:
return "."
else:
return ",".join(map(format_atomic, value)) |
<SYSTEM_TASK:>
Serialize whole Record
<END_TASK>
<USER_TASK:>
Description:
def _serialize_record(self, record):
"""Serialize whole Record""" |
f = self._empty_to_dot
row = [record.CHROM, record.POS]
row.append(f(";".join(record.ID)))
row.append(f(record.REF))
if not record.ALT:
row.append(".")
else:
row.append(",".join([f(a.serialize()) for a in record.ALT]))
row.append(f(record.QUAL))
row.append(f(";".join(record.FILTER)))
row.append(f(self._serialize_info(record)))
if record.FORMAT:
row.append(":".join(record.FORMAT))
row += [
self._serialize_call(record.FORMAT, record.call_for_sample[s])
for s in self.header.samples.names
]
print(*row, sep="\t", file=self.stream) |
<SYSTEM_TASK:>
Return serialized version of record.INFO
<END_TASK>
<USER_TASK:>
Description:
def _serialize_info(self, record):
"""Return serialized version of record.INFO""" |
result = []
for key, value in record.INFO.items():
info = self.header.get_info_field_info(key)
if info.type == "Flag":
result.append(key)
else:
result.append("{}={}".format(key, format_value(info, value, "INFO")))
return ";".join(result) |
<SYSTEM_TASK:>
Return serialized version of the Call using the record's FORMAT
<END_TASK>
<USER_TASK:>
Description:
def _serialize_call(self, format_, call):
"""Return serialized version of the Call using the record's FORMAT'""" |
if isinstance(call, record.UnparsedCall):
return call.unparsed_data
else:
result = [
format_value(self.header.get_format_field_info(key), call.data.get(key), "FORMAT")
for key in format_
]
return ":".join(result) |
<SYSTEM_TASK:>
Loops through the nodes and looks for special jinja tags that
<END_TASK>
<USER_TASK:>
Description:
def _create_extended_jinja_tags(self, nodes):
"""Loops through the nodes and looks for special jinja tags that
contains more than one tag but only one ending tag.""" |
jinja_a = None
jinja_b = None
ext_node = None
ext_nodes = []
for node in nodes:
if isinstance(node, EmptyLine):
continue
if node.has_children():
node.children = self._create_extended_jinja_tags(node.children)
if not isinstance(node, JinjaTag):
jinja_a = None
continue
if jinja_a is None or (
node.tag_name in self._extended_tags and jinja_a.tag_name not in self._extended_tags[node.tag_name]):
jinja_a = node
continue
if node.tag_name in self._extended_tags and \
jinja_a.tag_name in self._extended_tags[node.tag_name]:
if ext_node is None:
ext_node = ExtendedJinjaTag()
ext_node.add(jinja_a)
ext_nodes.append(ext_node)
ext_node.add(node)
else:
ext_node = None
jinja_a = node
#replace the nodes with the new extended node
for node in ext_nodes:
nodes.insert(nodes.index(node.children[0]), node)
index = nodes.index(node.children[0])
del nodes[index:index+len(node.children)]
return nodes |
<SYSTEM_TASK:>
Get screenshots from all cams at defined intervall.
<END_TASK>
<USER_TASK:>
Description:
def watch(cams, path=None, delay=10):
"""Get screenshots from all cams at defined intervall.""" |
while True:
for c in cams:
c.snap(path)
time.sleep(delay) |
<SYSTEM_TASK:>
Score is an API that delivers reputation scoring based on phone number intelligence, traffic patterns, machine
<END_TASK>
<USER_TASK:>
Description:
def score(self, phone_number, account_lifecycle_event, **params):
"""
Score is an API that delivers reputation scoring based on phone number intelligence, traffic patterns, machine
learning, and a global data consortium.
See https://developer.telesign.com/docs/score-api for detailed API documentation.
""" |
return self.post(SCORE_RESOURCE.format(phone_number=phone_number),
account_lifecycle_event=account_lifecycle_event,
**params) |
<SYSTEM_TASK:>
Generates the TeleSign REST API headers used to authenticate requests.
<END_TASK>
<USER_TASK:>
Description:
def generate_telesign_headers(customer_id,
api_key,
method_name,
resource,
url_encoded_fields,
date_rfc2616=None,
nonce=None,
user_agent=None,
content_type=None):
"""
Generates the TeleSign REST API headers used to authenticate requests.
Creates the canonicalized string_to_sign and generates the HMAC signature. This is used to authenticate requests
against the TeleSign REST API.
See https://developer.telesign.com/docs/authentication for detailed API documentation.
:param customer_id: Your account customer_id.
:param api_key: Your account api_key.
:param method_name: The HTTP method name of the request as a upper case string, should be one of 'POST', 'GET',
'PUT' or 'DELETE'.
:param resource: The partial resource URI to perform the request against, as a string.
:param url_encoded_fields: HTTP body parameters to perform the HTTP request with, must be a urlencoded string.
:param date_rfc2616: The date and time of the request formatted in rfc 2616, as a string.
:param nonce: A unique cryptographic nonce for the request, as a string.
:param user_agent: (optional) User Agent associated with the request, as a string.
:param content_type: (optional) ContentType of the request, as a string.
:return: The TeleSign authentication headers.
""" |
if date_rfc2616 is None:
date_rfc2616 = formatdate(usegmt=True)
if nonce is None:
nonce = str(uuid.uuid4())
if not content_type:
content_type = "application/x-www-form-urlencoded" if method_name in ("POST", "PUT") else ""
auth_method = "HMAC-SHA256"
string_to_sign_builder = ["{method}".format(method=method_name)]
string_to_sign_builder.append("\n{content_type}".format(content_type=content_type))
string_to_sign_builder.append("\n{date}".format(date=date_rfc2616))
string_to_sign_builder.append("\nx-ts-auth-method:{auth_method}".format(auth_method=auth_method))
string_to_sign_builder.append("\nx-ts-nonce:{nonce}".format(nonce=nonce))
if content_type and url_encoded_fields:
string_to_sign_builder.append("\n{fields}".format(fields=url_encoded_fields))
string_to_sign_builder.append("\n{resource}".format(resource=resource))
string_to_sign = "".join(string_to_sign_builder)
signer = hmac.new(b64decode(api_key), string_to_sign.encode("utf-8"), sha256)
signature = b64encode(signer.digest()).decode("utf-8")
authorization = "TSA {customer_id}:{signature}".format(
customer_id=customer_id,
signature=signature)
headers = {
"Authorization": authorization,
"Date": date_rfc2616,
"Content-Type": content_type,
"x-ts-auth-method": auth_method,
"x-ts-nonce": nonce
}
if user_agent:
headers['User-Agent'] = user_agent
return headers |
<SYSTEM_TASK:>
Generic TeleSign REST API POST handler.
<END_TASK>
<USER_TASK:>
Description:
def post(self, resource, **params):
"""
Generic TeleSign REST API POST handler.
:param resource: The partial resource URI to perform the request against, as a string.
:param params: Body params to perform the POST request with, as a dictionary.
:return: The RestClient Response object.
""" |
return self._execute(self.session.post, 'POST', resource, **params) |
<SYSTEM_TASK:>
Generic TeleSign REST API GET handler.
<END_TASK>
<USER_TASK:>
Description:
def get(self, resource, **params):
"""
Generic TeleSign REST API GET handler.
:param resource: The partial resource URI to perform the request against, as a string.
:param params: Body params to perform the GET request with, as a dictionary.
:return: The RestClient Response object.
""" |
return self._execute(self.session.get, 'GET', resource, **params) |
<SYSTEM_TASK:>
Generic TeleSign REST API PUT handler.
<END_TASK>
<USER_TASK:>
Description:
def put(self, resource, **params):
"""
Generic TeleSign REST API PUT handler.
:param resource: The partial resource URI to perform the request against, as a string.
:param params: Body params to perform the PUT request with, as a dictionary.
:return: The RestClient Response object.
""" |
return self._execute(self.session.put, 'PUT', resource, **params) |
<SYSTEM_TASK:>
Generic TeleSign REST API DELETE handler.
<END_TASK>
<USER_TASK:>
Description:
def delete(self, resource, **params):
"""
Generic TeleSign REST API DELETE handler.
:param resource: The partial resource URI to perform the request against, as a string.
:param params: Body params to perform the DELETE request with, as a dictionary.
:return: The RestClient Response object.
""" |
return self._execute(self.session.delete, 'DELETE', resource, **params) |
<SYSTEM_TASK:>
Generic TeleSign REST API request handler.
<END_TASK>
<USER_TASK:>
Description:
def _execute(self, method_function, method_name, resource, **params):
"""
Generic TeleSign REST API request handler.
:param method_function: The Requests HTTP request function to perform the request.
:param method_name: The HTTP method name, as an upper case string.
:param resource: The partial resource URI to perform the request against, as a string.
:param params: Body params to perform the HTTP request with, as a dictionary.
:return: The RestClient Response object.
""" |
resource_uri = "{api_host}{resource}".format(api_host=self.api_host, resource=resource)
url_encoded_fields = self._encode_params(params)
headers = RestClient.generate_telesign_headers(self.customer_id,
self.api_key,
method_name,
resource,
url_encoded_fields,
user_agent=self.user_agent)
if method_name in ['POST', 'PUT']:
payload = {'data': url_encoded_fields}
else:
payload = {'params': url_encoded_fields}
response = self.Response(method_function(resource_uri,
headers=headers,
timeout=self.timeout,
**payload))
return response |
<SYSTEM_TASK:>
Send a message to the target phone_number.
<END_TASK>
<USER_TASK:>
Description:
def message(self, phone_number, message, message_type, **params):
"""
Send a message to the target phone_number.
See https://developer.telesign.com/docs/messaging-api for detailed API documentation.
""" |
return self.post(MESSAGING_RESOURCE,
phone_number=phone_number,
message=message,
message_type=message_type,
**params) |
<SYSTEM_TASK:>
The PhoneID API provides a cleansed phone number, phone type, and telecom carrier information to determine the
<END_TASK>
<USER_TASK:>
Description:
def phoneid(self, phone_number, **params):
"""
The PhoneID API provides a cleansed phone number, phone type, and telecom carrier information to determine the
best communication method - SMS or voice.
See https://developer.telesign.com/docs/phoneid-api for detailed API documentation.
""" |
return self.post(PHONEID_RESOURCE.format(phone_number=phone_number),
**params) |
<SYSTEM_TASK:>
Returns a new instance which identical to this instance.
<END_TASK>
<USER_TASK:>
Description:
def copy(self):
"""Returns a new instance which identical to this instance.""" |
if self._pre_computed_hash is None:
temp = ssdeep(buf="")
else:
temp = ssdeep(hash=hash)
libssdeep_wrapper.fuzzy_free(temp._state)
temp._state = libssdeep_wrapper.fuzzy_clone(self._state)
temp._updatable = self._updatable
temp._pre_computed_hash = self._pre_computed_hash
return temp |
<SYSTEM_TASK:>
Send a voice call to the target phone_number.
<END_TASK>
<USER_TASK:>
Description:
def call(self, phone_number, message, message_type, **params):
"""
Send a voice call to the target phone_number.
See https://developer.telesign.com/docs/voice-api for detailed API documentation.
""" |
return self.post(VOICE_RESOURCE,
phone_number=phone_number,
message=message,
message_type=message_type,
**params) |
<SYSTEM_TASK:>
Retrieves the verification result for an App Verify transaction by external_id. To ensure a secure verification
<END_TASK>
<USER_TASK:>
Description:
def status(self, external_id, **params):
"""
Retrieves the verification result for an App Verify transaction by external_id. To ensure a secure verification
flow you must check the status using TeleSign's servers on your backend. Do not rely on the SDK alone to
indicate a successful verification.
See https://developer.telesign.com/docs/app-verify-android-sdk-self#section-get-status-service or
https://developer.telesign.com/docs/app-verify-ios-sdk-self#section-get-status-service for detailed
API documentation.
""" |
return self.get(APPVERIFY_STATUS_RESOURCE.format(external_id=external_id),
**params) |
<SYSTEM_TASK:>
Get Asset Location.
<END_TASK>
<USER_TASK:>
Description:
def get_asset_location(element, attr):
"""
Get Asset Location.
Remove leading slash e.g '/static/images.jpg' ==> static/images.jpg
Also, if the url is also prefixed with static, it would be removed.
e.g static/image.jpg ==> image.jpg
""" |
asset_location = re.match(r'^/?(static)?/?(.*)', element[attr],
re.IGNORECASE)
# replace relative links i.e (../../static)
asset_location = asset_location.group(2).replace('../', '')
return asset_location |
<SYSTEM_TASK:>
The actual transformation occurs here.
<END_TASK>
<USER_TASK:>
Description:
def transform(matches, framework, namespace, static_endpoint):
"""
The actual transformation occurs here.
flask example: images/staticfy.jpg', ==>
"{{ url_for('static', filename='images/staticfy.jpg') }}"
""" |
transformed = []
namespace = namespace + '/' if namespace else ''
for attribute, elements in matches:
for element in elements:
asset_location = get_asset_location(element, attribute)
# string substitution
sub_dict = {
'static_endpoint': static_endpoint, 'namespace': namespace,
'asset_location': asset_location
}
transformed_string = frameworks[framework] % sub_dict
res = (attribute, element[attribute], transformed_string)
transformed.append(res)
return transformed |
<SYSTEM_TASK:>
Extract all the elements we're interested in.
<END_TASK>
<USER_TASK:>
Description:
def get_elements(html_file, tags):
"""
Extract all the elements we're interested in.
Returns a list of tuples with the attribute as first item
and the list of elements as the second item.
""" |
with open(html_file) as f:
document = BeautifulSoup(f, 'html.parser')
def condition(tag, attr):
# Don't include external links
return lambda x: x.name == tag \
and not x.get(attr, 'http').startswith(('http', '//'))
all_tags = [(attr, document.find_all(condition(tag, attr)))
for tag, attr in tags]
return all_tags |
<SYSTEM_TASK:>
Replace lines in the old file with the transformed lines.
<END_TASK>
<USER_TASK:>
Description:
def replace_lines(html_file, transformed):
"""Replace lines in the old file with the transformed lines.""" |
result = []
with codecs.open(html_file, 'r', 'utf-8') as input_file:
for line in input_file:
# replace all single quotes with double quotes
line = re.sub(r'\'', '"', line)
for attr, value, new_link in transformed:
if attr in line and value in line:
# replace old link with new staticfied link
new_line = line.replace(value, new_link)
result.append(new_line)
break
else:
result.append(line)
return ''.join(result) |
<SYSTEM_TASK:>
Staticfy method.
<END_TASK>
<USER_TASK:>
Description:
def staticfy(html_file, args=argparse.ArgumentParser()):
"""
Staticfy method.
Loop through each line of the file and replaces the old links
""" |
# unpack arguments
static_endpoint = args.static_endpoint or 'static'
framework = args.framework or os.getenv('STATICFY_FRAMEWORK', 'flask')
add_tags = args.add_tags or {}
exc_tags = args.exc_tags or {}
namespace = args.namespace or {}
# default tags
tags = {('img', 'src'), ('link', 'href'), ('script', 'src')}
# generate additional_tags
add_tags = {(tag, attr) for tag, attr in add_tags.items()}
tags.update(add_tags)
# remove tags if any was specified
exc_tags = {(tag, attr) for tag, attr in exc_tags.items()}
tags = tags - exc_tags
# get elements we're interested in
matches = get_elements(html_file, tags)
# transform old links to new links
transformed = transform(matches, framework, namespace, static_endpoint)
return replace_lines(html_file, transformed) |
<SYSTEM_TASK:>
Write to stdout or a file
<END_TASK>
<USER_TASK:>
Description:
def file_ops(staticfied, args):
"""Write to stdout or a file""" |
destination = args.o or args.output
if destination:
with open(destination, 'w') as file:
file.write(staticfied)
else:
print(staticfied) |
<SYSTEM_TASK:>
Get keys specified in arguments
<END_TASK>
<USER_TASK:>
Description:
def find_keys(args):
"""Get keys specified in arguments
returns list of keys or None
""" |
key = args['--key']
if key:
return [key]
keyfile = args['--apikeys']
if keyfile:
return read_keyfile(keyfile)
envkey = os.environ.get('TINYPNG_API_KEY', None)
if envkey:
return [envkey]
local_keys = join(abspath("."), "tinypng.keys")
if isfile(local_keys):
return read_keyfile(local_keys)
home_keys = join(expanduser("~/.tinypng.keys"))
if isfile(home_keys):
return read_keyfile(home_keys)
return [] |
<SYSTEM_TASK:>
Shrink png file and write it back to a new file
<END_TASK>
<USER_TASK:>
Description:
def shrink_file(in_filepath, api_key=None, out_filepath=None):
"""Shrink png file and write it back to a new file
The default file path replaces ".png" with ".tiny.png".
returns api_info (including info['ouput']['filepath'])
""" |
info = get_shrink_file_info(in_filepath, api_key, out_filepath)
write_shrunk_file(info)
return info |
<SYSTEM_TASK:>
Verify that a callback was made by TeleSign and was not sent by a malicious client by verifying the signature.
<END_TASK>
<USER_TASK:>
Description:
def verify_telesign_callback_signature(api_key, signature, json_str):
"""
Verify that a callback was made by TeleSign and was not sent by a malicious client by verifying the signature.
:param api_key: the TeleSign API api_key associated with your account.
:param signature: the TeleSign Authorization header value supplied in the callback, as a string.
:param json_str: the POST body text, that is, the JSON string sent by TeleSign describing the transaction status.
""" |
your_signature = b64encode(HMAC(b64decode(api_key), json_str.encode("utf-8"), sha256).digest()).decode("utf-8")
if len(signature) != len(your_signature):
return False
# avoid timing attack with constant time equality check
signatures_equal = True
for x, y in zip(signature, your_signature):
if not x == y:
signatures_equal = False
return signatures_equal |
<SYSTEM_TASK:>
The move format is in long algebraic notation.
<END_TASK>
<USER_TASK:>
Description:
def setposition(self, position):
"""
The move format is in long algebraic notation.
Takes list of stirngs = ['e2e4', 'd7d5']
OR
FEN = 'rnbqkbnr/pppppppp/8/8/4P3/8/PPPP1PPP/RNBQKBNR b KQkq e3 0 1'
""" |
try:
if isinstance(position, list):
self.send('position startpos moves {}'.format(
self.__listtostring(position)))
self.isready()
elif re.match('\s*^(((?:[rnbqkpRNBQKP1-8]+\/){7})[rnbqkpRNBQKP1-8]+)\s([b|w])\s([K|Q|k|q|-]{1,4})\s(-|[a-h][1-8])\s(\d+\s\d+)$', position):
regexList = re.match('\s*^(((?:[rnbqkpRNBQKP1-8]+\/){7})[rnbqkpRNBQKP1-8]+)\s([b|w])\s([K|Q|k|q|-]{1,4})\s(-|[a-h][1-8])\s(\d+\s\d+)$', position).groups()
fen = regexList[0].split("/")
if len(fen) != 8:
raise ValueError("expected 8 rows in position part of fen: {0}".format(repr(fen)))
for fenPart in fen:
field_sum = 0
previous_was_digit, previous_was_piece = False, False
for c in fenPart:
if c in ["1", "2", "3", "4", "5", "6", "7", "8"]:
if previous_was_digit:
raise ValueError("two subsequent digits in position part of fen: {0}".format(repr(fen)))
field_sum += int(c)
previous_was_digit = True
previous_was_piece = False
elif c == "~":
if not previous_was_piece:
raise ValueError("~ not after piece in position part of fen: {0}".format(repr(fen)))
previous_was_digit, previous_was_piece = False, False
elif c.lower() in ["p", "n", "b", "r", "q", "k"]:
field_sum += 1
previous_was_digit = False
previous_was_piece = True
else:
raise ValueError("invalid character in position part of fen: {0}".format(repr(fen)))
if field_sum != 8:
raise ValueError("expected 8 columns per row in position part of fen: {0}".format(repr(fen)))
self.send('position fen {}'.format(position))
self.isready()
else: raise ValueError("fen doesn`t match follow this example: rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1 ")
except ValueError as e:
print('\nCheck position correctness\n')
sys.exit(e.message) |
<SYSTEM_TASK:>
Add a single item into DataContainer
<END_TASK>
<USER_TASK:>
Description:
def add_item(self, host, key, value, clock=None, state=0):
"""
Add a single item into DataContainer
:host: hostname to which item will be linked to
:key: item key as defined in Zabbix
:value: item value
:clock: timestemp as integer. If not provided self.clock()) will be used
""" |
if clock is None:
clock = self.clock
if self._config.data_type == "items":
item = {"host": host, "key": key,
"value": value, "clock": clock, "state": state}
elif self._config.data_type == "lld":
item = {"host": host, "key": key, "clock": clock, "state": state,
"value": json.dumps({"data": value})}
else:
if self.logger: # pragma: no cover
self.logger.error("Setup data_type before adding data")
raise ValueError('Setup data_type before adding data')
self._items_list.append(item) |
<SYSTEM_TASK:>
Add a list of item into the container
<END_TASK>
<USER_TASK:>
Description:
def add(self, data):
"""
Add a list of item into the container
:data: dict of items & value per hostname
""" |
for host in data:
for key in data[host]:
if not data[host][key] == []:
self.add_item(host, key, data[host][key]) |
<SYSTEM_TASK:>
Common part of sending operations
<END_TASK>
<USER_TASK:>
Description:
def _send_common(self, item):
"""
Common part of sending operations
Calls SenderProtocol._send_to_zabbix
Returns result as provided by _handle_response
:item: either a list or a single item depending on debug_level
""" |
total = len(item)
processed = failed = time = 0
if self._config.dryrun is True:
total = len(item)
processed = failed = time = 0
response = 'dryrun'
else:
self._send_to_zabbix(item)
response, processed, failed, total, time = self._read_from_zabbix()
output_key = '(bulk)'
output_item = '(bulk)'
if self.debug_level >= 4:
output_key = item[0]['key']
output_item = item[0]['value']
if self.logger: # pragma: no cover
self.logger.info(
"" +
ZBX_DBG_SEND_RESULT % (
processed,
failed,
total,
output_key,
output_item,
response
)
)
return response, processed, failed, total, time |
<SYSTEM_TASK:>
Set logger instance for the class
<END_TASK>
<USER_TASK:>
Description:
def logger(self, value):
"""
Set logger instance for the class
""" |
if isinstance(value, logging.Logger):
self._logger = value
else:
if self._logger: # pragma: no cover
self._logger.error("logger requires a logging instance")
raise ValueError('logger requires a logging instance') |
<SYSTEM_TASK:>
Returns a full representation of the issue for the given issue key.
<END_TASK>
<USER_TASK:>
Description:
def get_issue(self, issue_id, params=None):
"""Returns a full representation of the issue for the given issue key.
The issue JSON consists of the issue key and a collection of fields. Additional information like links to
workflow transition sub-resources, or HTML rendered values of the fields supporting HTML rendering can be
retrieved with expand request parameter specified.
The fields request parameter accepts a comma-separated list of fields to include in the response. It can be used
to retrieve a subset of fields. By default all fields are returned in the response. A particular field can be
excluded from the response if prefixed with a "-" (minus) sign. Parameter can be provided multiple times on a
single request.
By default, all fields are returned in the response. Note: this is different from a JQL search - only navigable
fields are returned by default (*navigable).
Args:
issue_id:
params:
Returns:
""" |
return self._get(self.API_URL + 'issue/{}'.format(issue_id), params=params) |
<SYSTEM_TASK:>
Creates an issue or a sub-task from a JSON representation.
<END_TASK>
<USER_TASK:>
Description:
def create_issue(self, data, params=None):
"""Creates an issue or a sub-task from a JSON representation.
You can provide two parameters in request's body: update or fields. The fields, that can be set on an issue
create operation, can be determined using the /rest/api/2/issue/createmeta resource. If a particular field is
not configured to appear on the issue's Create screen, then it will not be returned in the createmeta response.
A field validation error will occur if such field is submitted in request.
Creating a sub-task is similar to creating an issue with the following differences:
issueType field must be set to a sub-task issue type (use /issue/createmeta to find sub-task issue types), and
You must provide a parent field with the ID or key of the parent issue.
Args:
data:
params:
Returns:
""" |
return self._post(self.API_URL + 'issue', data=data, params=params) |
<SYSTEM_TASK:>
Deletes an individual issue.
<END_TASK>
<USER_TASK:>
Description:
def delete_issue(self, issue_id, params=None):
"""Deletes an individual issue.
If the issue has sub-tasks you must set the deleteSubtasks=true parameter to delete the issue. You cannot delete
an issue without deleting its sub-tasks.
Args:
issue_id:
params:
Returns:
""" |
return self._delete(self.API_URL + 'issue/{}'.format(issue_id), params=params) |
<SYSTEM_TASK:>
Retrieves a list of objects.
<END_TASK>
<USER_TASK:>
Description:
def list(self, pagination=True, page_size=None, page=None, **queryparams):
"""
Retrieves a list of objects.
By default uses local cache and remote pagination
If pagination is used and no page is requested (the default), all the
remote objects are retrieved and appended in a single list.
If pagination is disabled, all the objects are fetched from the
endpoint and returned. This may trigger some parsing error if the
result set is very large.
:param pagination: Use pagination (default: `True`)
:param page_size: Size of the pagination page (default: `100`).
Any non numeric value will be casted to the
default value
:param page: Page number to retrieve (default: `None`). Ignored if
`pagination` is `False`
:param queryparams: Additional filter parameters as accepted by the
remote API
:return: <SearchableList>
""" |
if page_size and pagination:
try:
page_size = int(page_size)
except (ValueError, TypeError):
page_size = 100
queryparams['page_size'] = page_size
result = self.requester.get(
self.instance.endpoint, query=queryparams, paginate=pagination
)
objects = SearchableList()
objects.extend(self.parse_list(result.json()))
if result.headers.get('X-Pagination-Next', False) and not page:
next_page = 2
else:
next_page = None
while next_page:
pageparams = queryparams.copy()
pageparams['page'] = next_page
result = self.requester.get(
self.instance.endpoint, query=pageparams,
)
objects.extend(self.parse_list(result.json()))
if result.headers.get('X-Pagination-Next', False):
next_page += 1
else:
next_page = None
return objects |
<SYSTEM_TASK:>
Turns a JSON object into a model instance.
<END_TASK>
<USER_TASK:>
Description:
def parse(cls, requester, entry):
"""
Turns a JSON object into a model instance.
""" |
if not type(entry) is dict:
return entry
for key_to_parse, cls_to_parse in six.iteritems(cls.parser):
if key_to_parse in entry:
entry[key_to_parse] = cls_to_parse.parse(
requester, entry[key_to_parse]
)
return cls(requester, **entry) |
<SYSTEM_TASK:>
Set attribute to a specific value
<END_TASK>
<USER_TASK:>
Description:
def set_attribute(self, id, value, version=1):
"""
Set attribute to a specific value
:param id: id of the attribute
:param value: value of the attribute
:param version: version of the attribute (default = 1)
""" |
attributes = self._get_attributes(cache=True)
formatted_id = '{0}'.format(id)
attributes['attributes_values'][formatted_id] = value
response = self.requester.patch(
'/{endpoint}/custom-attributes-values/{id}',
endpoint=self.endpoint, id=self.id,
payload={
'attributes_values': attributes['attributes_values'],
'version': version
}
)
cache_key = self.requester.get_full_url(
'/{endpoint}/custom-attributes-values/{id}',
endpoint=self.endpoint, id=self.id
)
self.requester.cache.put(cache_key, response)
return response.json() |
<SYSTEM_TASK:>
Get stats for issues of the project
<END_TASK>
<USER_TASK:>
Description:
def issues_stats(self):
"""
Get stats for issues of the project
""" |
response = self.requester.get(
'/{endpoint}/{id}/issues_stats',
endpoint=self.endpoint, id=self.id
)
return response.json() |
<SYSTEM_TASK:>
Like the project
<END_TASK>
<USER_TASK:>
Description:
def like(self):
"""
Like the project
""" |
self.requester.post(
'/{endpoint}/{id}/like',
endpoint=self.endpoint, id=self.id
)
return self |
<SYSTEM_TASK:>
Unlike the project
<END_TASK>
<USER_TASK:>
Description:
def unlike(self):
"""
Unlike the project
""" |
self.requester.post(
'/{endpoint}/{id}/unlike',
endpoint=self.endpoint, id=self.id
)
return self |
<SYSTEM_TASK:>
Stars the project
<END_TASK>
<USER_TASK:>
Description:
def star(self):
"""
Stars the project
.. deprecated:: 0.8.5
Update Taiga and use like instead
""" |
warnings.warn(
"Deprecated! Update Taiga and use .like() instead",
DeprecationWarning
)
self.requester.post(
'/{endpoint}/{id}/star',
endpoint=self.endpoint, id=self.id
)
return self |
<SYSTEM_TASK:>
Takes a class and a dict and try to build an instance of the class
<END_TASK>
<USER_TASK:>
Description:
def parse(cls, value):
"""Takes a class and a dict and try to build an instance of the class
:param cls: The class to parse
:param value: either a dict, a list or a scalar value
""" |
if is_list_annotation(cls):
if not isinstance(value, list):
raise TypeError('Could not parse {} because value is not a list'.format(cls))
return [parse(cls.__args__[0], o) for o in value]
else:
return GenericParser(cls, ModelProviderImpl()).parse(value) |
<SYSTEM_TASK:>
Log a request so that it matches our local log format.
<END_TASK>
<USER_TASK:>
Description:
def log_local_message(message_format, *args):
"""
Log a request so that it matches our local log format.
""" |
prefix = '{} {}'.format(color('INFO', fg=248), color('request', fg=5))
message = message_format % args
sys.stderr.write('{} {}\n'.format(prefix, message)) |
<SYSTEM_TASK:>
Takes a object and produces a dict-like representation
<END_TASK>
<USER_TASK:>
Description:
def serialize(obj):
"""Takes a object and produces a dict-like representation
:param obj: the object to serialize
""" |
if isinstance(obj, list):
return [serialize(o) for o in obj]
return GenericSerializer(ModelProviderImpl()).serialize(obj) |
<SYSTEM_TASK:>
By default, marks the block as expecting an indented "body" blocks of which are then supplied
<END_TASK>
<USER_TASK:>
Description:
def of(self, *indented_blocks) -> "CodeBlock":
"""
By default, marks the block as expecting an indented "body" blocks of which are then supplied
as arguments to this method.
Unless the block specifies a "closed_by", if no body blocks are supplied or they are all Nones,
this will generate a "pass" statement as the body. If there is a "closed_by" specified, then
that will be used on the same indentation level as the opening of the block.
After all the arguments have been handled, this block is marked as finalised and no more blocks
can be appended to it.
None blocks are skipped.
Returns the block itself.
""" |
if self.closed_by is None:
self.expects_body_or_pass = True
for block in indented_blocks:
if block is not None:
self._blocks.append((1, block))
# Finalise it so that we cannot add more sub-blocks to this block.
self.finalise()
return self |
<SYSTEM_TASK:>
Adds sub-blocks at the specified indentation level, which defaults to 0.
<END_TASK>
<USER_TASK:>
Description:
def add(self, *blocks, indentation=0) -> "CodeBlock":
"""
Adds sub-blocks at the specified indentation level, which defaults to 0.
Nones are skipped.
Returns the parent block itself, useful for chaining.
""" |
for block in blocks:
if block is not None:
self._blocks.append((indentation, block))
return self |
<SYSTEM_TASK:>
Generate the code and return it as a string.
<END_TASK>
<USER_TASK:>
Description:
def to_code(self, context: Context =None):
"""
Generate the code and return it as a string.
""" |
# Do not override this method!
context = context or Context()
for imp in self.imports:
if imp not in context.imports:
context.imports.append(imp)
counter = Counter()
lines = list(self.to_lines(context=context, counter=counter))
if counter.num_indented_non_doc_blocks == 0:
if self.expects_body_or_pass:
lines.append(" pass")
elif self.closed_by:
lines[-1] += self.closed_by
else:
if self.closed_by:
lines.append(self.closed_by)
return join_lines(*lines) + self._suffix |
<SYSTEM_TASK:>
Execute simple code blocks.
<END_TASK>
<USER_TASK:>
Description:
def exec(self, globals=None, locals=None):
"""
Execute simple code blocks.
Do not attempt this on modules or other blocks where you have
imports as they won't work.
Instead write the code to a file and use runpy.run_path()
""" |
if locals is None:
locals = {}
builtins.exec(self.to_code(), globals, locals)
return locals |
<SYSTEM_TASK:>
Build a basic code block.
<END_TASK>
<USER_TASK:>
Description:
def block(self, *blocks, **kwargs) -> "CodeBlock":
"""
Build a basic code block.
Positional arguments should be instances of CodeBlock or strings.
All code blocks passed as positional arguments are added at indentation level 0.
None blocks are skipped.
""" |
assert "name" not in kwargs
kwargs.setdefault("code", self)
code = CodeBlock(**kwargs)
for block in blocks:
if block is not None:
code._blocks.append((0, block))
return code |
<SYSTEM_TASK:>
Generate code for a dictionary of locals whose value is not the specified literal.
<END_TASK>
<USER_TASK:>
Description:
def dict_from_locals(self, name, params: List[Parameter], not_specified_literal=Constants.VALUE_NOT_SET):
"""
Generate code for a dictionary of locals whose value is not the specified literal.
""" |
code = self.block(f"{name} = {{}}")
for p in params:
code.add(
self.block(f"if {p.name} is not {not_specified_literal}:").of(
f"{name}[{p.name!r}] = {p.name}"
),
)
return code |
<SYSTEM_TASK:>
Search in your Taiga.io instance
<END_TASK>
<USER_TASK:>
Description:
def search(self, project, text=''):
"""
Search in your Taiga.io instance
:param project: the project id
:param text: the query of your search
""" |
result = self.raw_request.get(
'search', query={'project': project, 'text': text}
)
result = result.json()
search_result = SearchResult()
search_result.tasks = self.tasks.parse_list(result['tasks'])
search_result.issues = self.issues.parse_list(result['issues'])
search_result.user_stories = self.user_stories.parse_list(
result['userstories']
)
search_result.wikipages = self.wikipages.parse_list(
result['wikipages']
)
return search_result |
<SYSTEM_TASK:>
Authenticate an app
<END_TASK>
<USER_TASK:>
Description:
def auth_app(self, app_id, app_secret, auth_code, state=''):
"""
Authenticate an app
:param app_id: the app id
:param app_secret: the app secret
:param auth_code: the app auth code
""" |
headers = {
'Content-type': 'application/json'
}
payload = {
'application': app_id,
'auth_code': auth_code,
'state': state
}
try:
full_url = utils.urljoin(
self.host,
'/api/v1/application-tokens/validate'
)
response = requests.post(
full_url,
data=json.dumps(payload),
headers=headers,
verify=self.tls_verify
)
except RequestException:
raise exceptions.TaigaRestException(
full_url, 400,
'NETWORK ERROR', 'POST'
)
if response.status_code != 200:
raise exceptions.TaigaRestException(
full_url,
response.status_code,
response.text,
'POST'
)
cyphered_token = response.json().get('cyphered_token', '')
if cyphered_token:
from jwkest.jwk import SYMKey
from jwkest.jwe import JWE
sym_key = SYMKey(key=app_secret, alg='A128KW')
data, success = JWE().decrypt(cyphered_token, keys=[sym_key]), True
if isinstance(data, tuple):
data, success = data
try:
self.token = json.loads(data.decode('utf-8')).get('token', None)
except ValueError: # pragma: no cover
self.token = None
if not success:
self.token = None
else:
self.token = None
if self.token is None:
raise exceptions.TaigaRestException(
full_url, 400,
'INVALID TOKEN', 'POST'
)
self.raw_request = RequestMaker('/api/v1', self.host, self.token,
'Application', self.tls_verify)
self._init_resources() |
<SYSTEM_TASK:>
Iterate over sorted members of shape in the same order in which
<END_TASK>
<USER_TASK:>
Description:
def sorted_members(self):
"""
Iterate over sorted members of shape in the same order in which
the members are declared except yielding the required members before
any optional members.
""" |
members = collections.OrderedDict()
required_names = self.metadata.get("required", ())
for name, shape in self.members.items():
members[name] = AbShapeMember(name=name, shape=shape, is_required=name in required_names)
if self.is_output_shape:
# ResponseMetadata is the first member for all output shapes.
yield AbShapeMember(
name="ResponseMetadata",
shape=self._shape_resolver.get_shape_by_name("ResponseMetadata"),
is_required=True,
)
yield from sorted(members.values(), key=lambda m: not m.is_required) |
<SYSTEM_TASK:>
decode byte strings and convert to int where needed
<END_TASK>
<USER_TASK:>
Description:
def _decode(value):
"""
decode byte strings and convert to int where needed
""" |
if value.isdigit():
return int(value)
if isinstance(value, bytes):
return value.decode('utf-8')
else:
return value |
<SYSTEM_TASK:>
Annotation function to set an Enum to be case insensitive on parsing
<END_TASK>
<USER_TASK:>
Description:
def caseinsensitive(cls):
"""Annotation function to set an Enum to be case insensitive on parsing""" |
if not issubclass(cls, Enum):
raise TypeError('caseinsensitive decorator can only be applied to subclasses of enum.Enum')
enum_options = getattr(cls, PYCKSON_ENUM_OPTIONS, {})
enum_options[ENUM_CASE_INSENSITIVE] = True
setattr(cls, PYCKSON_ENUM_OPTIONS, enum_options)
return cls |
<SYSTEM_TASK:>
Uses shell32.GetCommandLineArgvW to get sys.argv as a list of UTF-8
<END_TASK>
<USER_TASK:>
Description:
def win32_utf8_argv():
"""Uses shell32.GetCommandLineArgvW to get sys.argv as a list of UTF-8
strings.
Versions 2.5 and older of Python don't support Unicode in sys.argv on
Windows, with the underlying Windows API instead replacing multi-byte
characters with '?'.
Returns None on failure.
Example usage:
>>> def main(argv=None):
... if argv is None:
... argv = win32_utf8_argv() or sys.argv
...
""" |
try:
from ctypes import POINTER, byref, cdll, c_int, windll
from ctypes.wintypes import LPCWSTR, LPWSTR
GetCommandLineW = cdll.kernel32.GetCommandLineW
GetCommandLineW.argtypes = []
GetCommandLineW.restype = LPCWSTR
CommandLineToArgvW = windll.shell32.CommandLineToArgvW
CommandLineToArgvW.argtypes = [LPCWSTR, POINTER(c_int)]
CommandLineToArgvW.restype = POINTER(LPWSTR)
cmd = GetCommandLineW()
argc = c_int(0)
argv = CommandLineToArgvW(cmd, byref(argc))
if argc.value > 0:
# Remove Python executable if present
if argc.value - len(sys.argv) == 1:
start = 1
else:
start = 0
return [argv[i].encode('utf-8') for i in
range(start, argc.value)]
except Exception:
pass |
<SYSTEM_TASK:>
Encrypt data and return as ascii string. Hexadecimal digest as default.
<END_TASK>
<USER_TASK:>
Description:
def encrypt_ascii(self, data, key=None, v=None, extra_bytes=0,
digest="hex"):
"""
Encrypt data and return as ascii string. Hexadecimal digest as default.
Avaiable digests:
hex: Hexadecimal
base64: Base 64
hqx: hexbin4
""" |
digests = {"hex": binascii.b2a_hex,
"base64": binascii.b2a_base64,
"hqx": binascii.b2a_hqx}
digestor = digests.get(digest)
if not digestor:
TripleSecError(u"Digestor not supported.")
binary_result = self.encrypt(data, key, v, extra_bytes)
result = digestor(binary_result)
return result |
<SYSTEM_TASK:>
Receive ascii string and return decrypted data.
<END_TASK>
<USER_TASK:>
Description:
def decrypt_ascii(self, ascii_string, key=None, digest="hex"):
"""
Receive ascii string and return decrypted data.
Avaiable digests:
hex: Hexadecimal
base64: Base 64
hqx: hexbin4
""" |
digests = {"hex": binascii.a2b_hex,
"base64": binascii.a2b_base64,
"hqx": binascii.a2b_hqx}
digestor = digests.get(digest)
if not digestor:
TripleSecError(u"Digestor not supported.")
binary_string = digestor(ascii_string)
result = self.decrypt(binary_string, key)
return result |
<SYSTEM_TASK:>
Build a tree of commands.
<END_TASK>
<USER_TASK:>
Description:
def _build_cmd_tree(self, cmd_cls, cmd_name=None):
"""
Build a tree of commands.
:param cmd_cls:
The Command class or object to start with.
:param cmd_name:
Hard-coded name of the command (can be None for auto-detection)
:returns:
A tree structure represented as tuple
``(cmd_obj, cmd_name, children)``
Where ``cmd_obj`` is a Command instance, cmd_name is its name, if
any (it might be None) and ``children`` is a tuple of identical
tuples.
Note that command name auto-detection relies on
:meth:`guacamole.recipes.cmd.Command.get_cmd_name()`.
Let's look at a simple git-like example::
>>> from guacamole import Command
>>> class git_log(Command):
>>> pass
>>> class git_stash_list(Command):
>>> pass
>>> class git_stash(Command):
>>> sub_commands = (('list', git_stash_list),)
>>> class git(Command):
>>> sub_commands = (('log', git_log),
>>> ('stash', git_stash))
>>> build_cmd_tree(git)
(None, '<git>', (
('log', <git_log>, ()),
('stash', <git_stash>, (
('list', <git_stash_list>, ()),),),),)
""" |
if isinstance(cmd_cls, type):
cmd_obj = cmd_cls()
else:
cmd_obj = cmd_cls
if cmd_name is None:
cmd_name = cmd_obj.get_cmd_name()
return cmd_tree_node(cmd_name, cmd_obj, tuple([
self._build_cmd_tree(subcmd_cls, subcmd_name)
for subcmd_name, subcmd_cls in cmd_obj.get_sub_commands()])) |
<SYSTEM_TASK:>
Utility while developing to dump message data to play with in the
<END_TASK>
<USER_TASK:>
Description:
def debug_dump(message, file_prefix="dump"):
"""
Utility while developing to dump message data to play with in the
interpreter
""" |
global index
index += 1
with open("%s_%s.dump" % (file_prefix, index), 'w') as f:
f.write(message.SerializeToString())
f.close() |
<SYSTEM_TASK:>
Get a player attribute that depends on which side the player is on.
<END_TASK>
<USER_TASK:>
Description:
def get_side_attr(attr, invert, player):
"""
Get a player attribute that depends on which side the player is on.
A creep kill for a radiant hero is a badguy_kill, while a creep kill
for a dire hero is a goodguy_kill.
""" |
t = player.team
if invert:
t = not player.team
return getattr(player, "%s_%s" % ("goodguy" if t else "badguy", attr)) |
<SYSTEM_TASK:>
The chat messages that arrive when certain events occur.
<END_TASK>
<USER_TASK:>
Description:
def parse_dota_um(self, event):
"""
The chat messages that arrive when certain events occur.
The most useful ones are CHAT_MESSAGE_RUNE_PICKUP,
CHAT_MESSAGE_RUNE_BOTTLE, CHAT_MESSAGE_GLYPH_USED,
CHAT_MESSAGE_TOWER_KILL
""" |
if event.type == dota_usermessages_pb2.CHAT_MESSAGE_AEGIS:
self.aegis.append((self.tick, event.playerid_1)) |
<SYSTEM_TASK:>
Parse a PlayerInfo struct. This arrives before a FileInfo message
<END_TASK>
<USER_TASK:>
Description:
def parse_player_info(self, player):
"""
Parse a PlayerInfo struct. This arrives before a FileInfo message
""" |
if not player.ishltv:
self.player_info[player.name] = {
"user_id": player.userID,
"guid": player.guid,
"bot": player.fakeplayer,
} |
<SYSTEM_TASK:>
The CDemoFileInfo contains our winners as well as the length of the
<END_TASK>
<USER_TASK:>
Description:
def parse_file_info(self, file_info):
"""
The CDemoFileInfo contains our winners as well as the length of the
demo
""" |
self.info["playback_time"] = file_info.playback_time
self.info["match_id"] = file_info.game_info.dota.match_id
self.info["game_mode"] = file_info.game_info.dota.game_mode
self.info["game_winner"] = file_info.game_info.dota.game_winner
for index, player in enumerate(file_info.game_info.dota.player_info):
p = self.heroes[player.hero_name]
p.name = player.player_name
p.index = index
p.team = 0 if index < 5 else 1
self.indexed_players[index] = p
self.info["players"][player.player_name] = p |
<SYSTEM_TASK:>
Game events contain the combat log as well as 'chase_hero' events which
<END_TASK>
<USER_TASK:>
Description:
def parse_game_event(self, ge):
"""
Game events contain the combat log as well as 'chase_hero' events which
could be interesting
""" |
if ge.name == "dota_combatlog":
if ge.keys["type"] == 4:
#Something died
try:
source = self.dp.combat_log_names.get(ge.keys["sourcename"],
"unknown")
target = self.dp.combat_log_names.get(ge.keys["targetname"],
"unknown")
target_illusion = ge.keys["targetillusion"]
timestamp = ge.keys["timestamp"]
if (target.startswith("npc_dota_hero") and not
target_illusion):
self.kills.append({
"target": target,
"source": source,
"timestamp": timestamp,
"tick": self.tick,
})
elif source.startswith("npc_dota_hero"):
self.heroes[source].creep_kill(target, timestamp)
except KeyError:
"""
Sometimes we get combat logs for things we dont have in
combat_log_names. My theory is that the server sends
us incremental updates to the string table using
CSVCMsg_UpdateStringTable but I'm not sure how to parse
that
"""
pass |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.