repo stringlengths 7 55 | path stringlengths 4 127 | func_name stringlengths 1 88 | original_string stringlengths 75 19.8k | language stringclasses 1 value | code stringlengths 75 19.8k | code_tokens list | docstring stringlengths 3 17.3k | docstring_tokens list | sha stringlengths 40 40 | url stringlengths 87 242 | partition stringclasses 1 value |
|---|---|---|---|---|---|---|---|---|---|---|---|
frictionlessdata/goodtables-py | goodtables/inspector.py | _clean_empty | def _clean_empty(d):
"""Remove None values from a dict."""
if not isinstance(d, (dict, list)):
return d
if isinstance(d, list):
return [v for v in (_clean_empty(v) for v in d) if v is not None]
return {
k: v for k, v in
((k, _clean_empty(v)) for k, v in d.items())
if v is not None
} | python | def _clean_empty(d):
"""Remove None values from a dict."""
if not isinstance(d, (dict, list)):
return d
if isinstance(d, list):
return [v for v in (_clean_empty(v) for v in d) if v is not None]
return {
k: v for k, v in
((k, _clean_empty(v)) for k, v in d.items())
if v is not None
} | [
"def",
"_clean_empty",
"(",
"d",
")",
":",
"if",
"not",
"isinstance",
"(",
"d",
",",
"(",
"dict",
",",
"list",
")",
")",
":",
"return",
"d",
"if",
"isinstance",
"(",
"d",
",",
"list",
")",
":",
"return",
"[",
"v",
"for",
"v",
"in",
"(",
"_clean... | Remove None values from a dict. | [
"Remove",
"None",
"values",
"from",
"a",
"dict",
"."
] | 3e7d6891d2f4e342dfafbe0e951e204ccc252a44 | https://github.com/frictionlessdata/goodtables-py/blob/3e7d6891d2f4e342dfafbe0e951e204ccc252a44/goodtables/inspector.py#L330-L340 | train |
frictionlessdata/goodtables-py | goodtables/cells.py | create_cells | def create_cells(headers, schema_fields, values=None, row_number=None):
"""Create list of cells from headers, fields and values.
Args:
headers (List[str]): The headers values.
schema_fields (List[tableschema.field.Field]): The tableschema
fields.
values (List[Any], optional): The cells values. If not specified,
the created cells will have the same values as their
corresponding headers. This is useful for specifying headers
cells.
If the list has any `None` values, as is the case on empty
cells, the resulting Cell will have an empty string value. If
the `values` list has a different length than the `headers`,
the resulting Cell will have value `None`.
row_number (int, optional): The row number.
Returns:
List[dict]: List of cells.
"""
fillvalue = '_fillvalue'
is_header_row = (values is None)
cells = []
iterator = zip_longest(headers, schema_fields, values or [], fillvalue=fillvalue)
for column_number, (header, field, value) in enumerate(iterator, start=1):
if header == fillvalue:
header = None
elif is_header_row:
value = header
if field == fillvalue:
field = None
if value == fillvalue:
value = None
elif value is None:
value = ''
cell = create_cell(header, value, field, column_number, row_number)
cells.append(cell)
return cells | python | def create_cells(headers, schema_fields, values=None, row_number=None):
"""Create list of cells from headers, fields and values.
Args:
headers (List[str]): The headers values.
schema_fields (List[tableschema.field.Field]): The tableschema
fields.
values (List[Any], optional): The cells values. If not specified,
the created cells will have the same values as their
corresponding headers. This is useful for specifying headers
cells.
If the list has any `None` values, as is the case on empty
cells, the resulting Cell will have an empty string value. If
the `values` list has a different length than the `headers`,
the resulting Cell will have value `None`.
row_number (int, optional): The row number.
Returns:
List[dict]: List of cells.
"""
fillvalue = '_fillvalue'
is_header_row = (values is None)
cells = []
iterator = zip_longest(headers, schema_fields, values or [], fillvalue=fillvalue)
for column_number, (header, field, value) in enumerate(iterator, start=1):
if header == fillvalue:
header = None
elif is_header_row:
value = header
if field == fillvalue:
field = None
if value == fillvalue:
value = None
elif value is None:
value = ''
cell = create_cell(header, value, field, column_number, row_number)
cells.append(cell)
return cells | [
"def",
"create_cells",
"(",
"headers",
",",
"schema_fields",
",",
"values",
"=",
"None",
",",
"row_number",
"=",
"None",
")",
":",
"fillvalue",
"=",
"'_fillvalue'",
"is_header_row",
"=",
"(",
"values",
"is",
"None",
")",
"cells",
"=",
"[",
"]",
"iterator",... | Create list of cells from headers, fields and values.
Args:
headers (List[str]): The headers values.
schema_fields (List[tableschema.field.Field]): The tableschema
fields.
values (List[Any], optional): The cells values. If not specified,
the created cells will have the same values as their
corresponding headers. This is useful for specifying headers
cells.
If the list has any `None` values, as is the case on empty
cells, the resulting Cell will have an empty string value. If
the `values` list has a different length than the `headers`,
the resulting Cell will have value `None`.
row_number (int, optional): The row number.
Returns:
List[dict]: List of cells. | [
"Create",
"list",
"of",
"cells",
"from",
"headers",
"fields",
"and",
"values",
"."
] | 3e7d6891d2f4e342dfafbe0e951e204ccc252a44 | https://github.com/frictionlessdata/goodtables-py/blob/3e7d6891d2f4e342dfafbe0e951e204ccc252a44/goodtables/cells.py#L4-L44 | train |
unixfreak0037/officeparser | officeparser.py | CompoundBinaryFile.__impl_read_chain | def __impl_read_chain(self, start, read_sector_f, read_fat_f):
"""Returns the entire contents of a chain starting at the given sector."""
sector = start
check = [ sector ] # keep a list of sectors we've already read
buffer = StringIO()
while sector != ENDOFCHAIN:
buffer.write(read_sector_f(sector))
next = read_fat_f(sector)
if next in check:
logging.error('infinite loop detected at {0} to {1} starting at {2}'.format(
sector, next, sector_start))
return buffer.getvalue()
check.append(next)
sector = next
return buffer.getvalue() | python | def __impl_read_chain(self, start, read_sector_f, read_fat_f):
"""Returns the entire contents of a chain starting at the given sector."""
sector = start
check = [ sector ] # keep a list of sectors we've already read
buffer = StringIO()
while sector != ENDOFCHAIN:
buffer.write(read_sector_f(sector))
next = read_fat_f(sector)
if next in check:
logging.error('infinite loop detected at {0} to {1} starting at {2}'.format(
sector, next, sector_start))
return buffer.getvalue()
check.append(next)
sector = next
return buffer.getvalue() | [
"def",
"__impl_read_chain",
"(",
"self",
",",
"start",
",",
"read_sector_f",
",",
"read_fat_f",
")",
":",
"sector",
"=",
"start",
"check",
"=",
"[",
"sector",
"]",
"buffer",
"=",
"StringIO",
"(",
")",
"while",
"sector",
"!=",
"ENDOFCHAIN",
":",
"buffer",
... | Returns the entire contents of a chain starting at the given sector. | [
"Returns",
"the",
"entire",
"contents",
"of",
"a",
"chain",
"starting",
"at",
"the",
"given",
"sector",
"."
] | 42c2d40372fe271f2039ca1adc145d2aef8c9545 | https://github.com/unixfreak0037/officeparser/blob/42c2d40372fe271f2039ca1adc145d2aef8c9545/officeparser.py#L247-L261 | train |
billy-yoyo/RainbowSixSiege-Python-API | r6sapi/r6sapi.py | Rank.get_charm_url | def get_charm_url(self):
"""Get charm URL for the bracket this rank is in
Returns
-------
:class:`str`
the URL for the charm
"""
if self.rank_id <= 4: return self.RANK_CHARMS[0]
if self.rank_id <= 8: return self.RANK_CHARMS[1]
if self.rank_id <= 12: return self.RANK_CHARMS[2]
if self.rank_id <= 16: return self.RANK_CHARMS[3]
if self.rank_id <= 19: return self.RANK_CHARMS[4]
return self.RANK_CHARMS[5] | python | def get_charm_url(self):
"""Get charm URL for the bracket this rank is in
Returns
-------
:class:`str`
the URL for the charm
"""
if self.rank_id <= 4: return self.RANK_CHARMS[0]
if self.rank_id <= 8: return self.RANK_CHARMS[1]
if self.rank_id <= 12: return self.RANK_CHARMS[2]
if self.rank_id <= 16: return self.RANK_CHARMS[3]
if self.rank_id <= 19: return self.RANK_CHARMS[4]
return self.RANK_CHARMS[5] | [
"def",
"get_charm_url",
"(",
"self",
")",
":",
"if",
"self",
".",
"rank_id",
"<=",
"4",
":",
"return",
"self",
".",
"RANK_CHARMS",
"[",
"0",
"]",
"if",
"self",
".",
"rank_id",
"<=",
"8",
":",
"return",
"self",
".",
"RANK_CHARMS",
"[",
"1",
"]",
"if... | Get charm URL for the bracket this rank is in
Returns
-------
:class:`str`
the URL for the charm | [
"Get",
"charm",
"URL",
"for",
"the",
"bracket",
"this",
"rank",
"is",
"in"
] | 9860fdfd9a78aabd977eaa71b0a4ab4ed69e94d0 | https://github.com/billy-yoyo/RainbowSixSiege-Python-API/blob/9860fdfd9a78aabd977eaa71b0a4ab4ed69e94d0/r6sapi/r6sapi.py#L808-L822 | train |
billy-yoyo/RainbowSixSiege-Python-API | r6sapi/r6sapi.py | Player.load_rank | def load_rank(self, region, season=-1):
"""|coro|
Loads the players rank for this region and season
Parameters
----------
region : str
the name of the region you want to get the rank for
season : Optional[int]
the season you want to get the rank for (defaults to -1, latest season)
Returns
-------
:class:`Rank`
the players rank for this region and season"""
data = yield from self.auth.get("https://public-ubiservices.ubi.com/v1/spaces/%s/sandboxes/%s/r6karma/players?board_id=pvp_ranked&profile_ids=%s®ion_id=%s&season_id=%s" % (self.spaceid, self.platform_url, self.id, region, season))
if "players" in data and self.id in data["players"]:
regionkey = "%s:%s" % (region, season)
self.ranks[regionkey] = Rank(data["players"][self.id])
return self.ranks[regionkey]
else:
raise InvalidRequest("Missing players key in returned JSON object %s" % str(data)) | python | def load_rank(self, region, season=-1):
"""|coro|
Loads the players rank for this region and season
Parameters
----------
region : str
the name of the region you want to get the rank for
season : Optional[int]
the season you want to get the rank for (defaults to -1, latest season)
Returns
-------
:class:`Rank`
the players rank for this region and season"""
data = yield from self.auth.get("https://public-ubiservices.ubi.com/v1/spaces/%s/sandboxes/%s/r6karma/players?board_id=pvp_ranked&profile_ids=%s®ion_id=%s&season_id=%s" % (self.spaceid, self.platform_url, self.id, region, season))
if "players" in data and self.id in data["players"]:
regionkey = "%s:%s" % (region, season)
self.ranks[regionkey] = Rank(data["players"][self.id])
return self.ranks[regionkey]
else:
raise InvalidRequest("Missing players key in returned JSON object %s" % str(data)) | [
"def",
"load_rank",
"(",
"self",
",",
"region",
",",
"season",
"=",
"-",
"1",
")",
":",
"data",
"=",
"yield",
"from",
"self",
".",
"auth",
".",
"get",
"(",
"\"https://public-ubiservices.ubi.com/v1/spaces/%s/sandboxes/%s/r6karma/players?board_id=pvp_ranked&profile_ids=%s... | |coro|
Loads the players rank for this region and season
Parameters
----------
region : str
the name of the region you want to get the rank for
season : Optional[int]
the season you want to get the rank for (defaults to -1, latest season)
Returns
-------
:class:`Rank`
the players rank for this region and season | [
"|coro|",
"Loads",
"the",
"players",
"rank",
"for",
"this",
"region",
"and",
"season"
] | 9860fdfd9a78aabd977eaa71b0a4ab4ed69e94d0 | https://github.com/billy-yoyo/RainbowSixSiege-Python-API/blob/9860fdfd9a78aabd977eaa71b0a4ab4ed69e94d0/r6sapi/r6sapi.py#L1114-L1136 | train |
NaturalHistoryMuseum/pylibdmtx | pylibdmtx/wrapper.py | libdmtx_function | def libdmtx_function(fname, restype, *args):
"""Returns a foreign function exported by `libdmtx`.
Args:
fname (:obj:`str`): Name of the exported function as string.
restype (:obj:): Return type - one of the `ctypes` primitive C data
types.
*args: Arguments - a sequence of `ctypes` primitive C data types.
Returns:
cddl.CFunctionType: A wrapper around the function.
"""
prototype = CFUNCTYPE(restype, *args)
return prototype((fname, load_libdmtx())) | python | def libdmtx_function(fname, restype, *args):
"""Returns a foreign function exported by `libdmtx`.
Args:
fname (:obj:`str`): Name of the exported function as string.
restype (:obj:): Return type - one of the `ctypes` primitive C data
types.
*args: Arguments - a sequence of `ctypes` primitive C data types.
Returns:
cddl.CFunctionType: A wrapper around the function.
"""
prototype = CFUNCTYPE(restype, *args)
return prototype((fname, load_libdmtx())) | [
"def",
"libdmtx_function",
"(",
"fname",
",",
"restype",
",",
"*",
"args",
")",
":",
"prototype",
"=",
"CFUNCTYPE",
"(",
"restype",
",",
"*",
"args",
")",
"return",
"prototype",
"(",
"(",
"fname",
",",
"load_libdmtx",
"(",
")",
")",
")"
] | Returns a foreign function exported by `libdmtx`.
Args:
fname (:obj:`str`): Name of the exported function as string.
restype (:obj:): Return type - one of the `ctypes` primitive C data
types.
*args: Arguments - a sequence of `ctypes` primitive C data types.
Returns:
cddl.CFunctionType: A wrapper around the function. | [
"Returns",
"a",
"foreign",
"function",
"exported",
"by",
"libdmtx",
"."
] | a425ec36050500af4875bf94eda02feb26ea62ad | https://github.com/NaturalHistoryMuseum/pylibdmtx/blob/a425ec36050500af4875bf94eda02feb26ea62ad/pylibdmtx/wrapper.py#L46-L59 | train |
NaturalHistoryMuseum/pylibdmtx | pylibdmtx/pylibdmtx.py | _image | def _image(pixels, width, height, pack):
"""A context manager for `DmtxImage`, created and destroyed by
`dmtxImageCreate` and `dmtxImageDestroy`.
Args:
pixels (:obj:):
width (int):
height (int):
pack (int):
Yields:
DmtxImage: The created image
Raises:
PyLibDMTXError: If the image could not be created.
"""
image = dmtxImageCreate(pixels, width, height, pack)
if not image:
raise PyLibDMTXError('Could not create image')
else:
try:
yield image
finally:
dmtxImageDestroy(byref(image)) | python | def _image(pixels, width, height, pack):
"""A context manager for `DmtxImage`, created and destroyed by
`dmtxImageCreate` and `dmtxImageDestroy`.
Args:
pixels (:obj:):
width (int):
height (int):
pack (int):
Yields:
DmtxImage: The created image
Raises:
PyLibDMTXError: If the image could not be created.
"""
image = dmtxImageCreate(pixels, width, height, pack)
if not image:
raise PyLibDMTXError('Could not create image')
else:
try:
yield image
finally:
dmtxImageDestroy(byref(image)) | [
"def",
"_image",
"(",
"pixels",
",",
"width",
",",
"height",
",",
"pack",
")",
":",
"image",
"=",
"dmtxImageCreate",
"(",
"pixels",
",",
"width",
",",
"height",
",",
"pack",
")",
"if",
"not",
"image",
":",
"raise",
"PyLibDMTXError",
"(",
"'Could not crea... | A context manager for `DmtxImage`, created and destroyed by
`dmtxImageCreate` and `dmtxImageDestroy`.
Args:
pixels (:obj:):
width (int):
height (int):
pack (int):
Yields:
DmtxImage: The created image
Raises:
PyLibDMTXError: If the image could not be created. | [
"A",
"context",
"manager",
"for",
"DmtxImage",
"created",
"and",
"destroyed",
"by",
"dmtxImageCreate",
"and",
"dmtxImageDestroy",
"."
] | a425ec36050500af4875bf94eda02feb26ea62ad | https://github.com/NaturalHistoryMuseum/pylibdmtx/blob/a425ec36050500af4875bf94eda02feb26ea62ad/pylibdmtx/pylibdmtx.py#L57-L80 | train |
NaturalHistoryMuseum/pylibdmtx | pylibdmtx/pylibdmtx.py | _decoder | def _decoder(image, shrink):
"""A context manager for `DmtxDecode`, created and destroyed by
`dmtxDecodeCreate` and `dmtxDecodeDestroy`.
Args:
image (POINTER(DmtxImage)):
shrink (int):
Yields:
POINTER(DmtxDecode): The created decoder
Raises:
PyLibDMTXError: If the decoder could not be created.
"""
decoder = dmtxDecodeCreate(image, shrink)
if not decoder:
raise PyLibDMTXError('Could not create decoder')
else:
try:
yield decoder
finally:
dmtxDecodeDestroy(byref(decoder)) | python | def _decoder(image, shrink):
"""A context manager for `DmtxDecode`, created and destroyed by
`dmtxDecodeCreate` and `dmtxDecodeDestroy`.
Args:
image (POINTER(DmtxImage)):
shrink (int):
Yields:
POINTER(DmtxDecode): The created decoder
Raises:
PyLibDMTXError: If the decoder could not be created.
"""
decoder = dmtxDecodeCreate(image, shrink)
if not decoder:
raise PyLibDMTXError('Could not create decoder')
else:
try:
yield decoder
finally:
dmtxDecodeDestroy(byref(decoder)) | [
"def",
"_decoder",
"(",
"image",
",",
"shrink",
")",
":",
"decoder",
"=",
"dmtxDecodeCreate",
"(",
"image",
",",
"shrink",
")",
"if",
"not",
"decoder",
":",
"raise",
"PyLibDMTXError",
"(",
"'Could not create decoder'",
")",
"else",
":",
"try",
":",
"yield",
... | A context manager for `DmtxDecode`, created and destroyed by
`dmtxDecodeCreate` and `dmtxDecodeDestroy`.
Args:
image (POINTER(DmtxImage)):
shrink (int):
Yields:
POINTER(DmtxDecode): The created decoder
Raises:
PyLibDMTXError: If the decoder could not be created. | [
"A",
"context",
"manager",
"for",
"DmtxDecode",
"created",
"and",
"destroyed",
"by",
"dmtxDecodeCreate",
"and",
"dmtxDecodeDestroy",
"."
] | a425ec36050500af4875bf94eda02feb26ea62ad | https://github.com/NaturalHistoryMuseum/pylibdmtx/blob/a425ec36050500af4875bf94eda02feb26ea62ad/pylibdmtx/pylibdmtx.py#L84-L105 | train |
NaturalHistoryMuseum/pylibdmtx | pylibdmtx/pylibdmtx.py | _region | def _region(decoder, timeout):
"""A context manager for `DmtxRegion`, created and destroyed by
`dmtxRegionFindNext` and `dmtxRegionDestroy`.
Args:
decoder (POINTER(DmtxDecode)):
timeout (int or None):
Yields:
DmtxRegion: The next region or None, if all regions have been found.
"""
region = dmtxRegionFindNext(decoder, timeout)
try:
yield region
finally:
if region:
dmtxRegionDestroy(byref(region)) | python | def _region(decoder, timeout):
"""A context manager for `DmtxRegion`, created and destroyed by
`dmtxRegionFindNext` and `dmtxRegionDestroy`.
Args:
decoder (POINTER(DmtxDecode)):
timeout (int or None):
Yields:
DmtxRegion: The next region or None, if all regions have been found.
"""
region = dmtxRegionFindNext(decoder, timeout)
try:
yield region
finally:
if region:
dmtxRegionDestroy(byref(region)) | [
"def",
"_region",
"(",
"decoder",
",",
"timeout",
")",
":",
"region",
"=",
"dmtxRegionFindNext",
"(",
"decoder",
",",
"timeout",
")",
"try",
":",
"yield",
"region",
"finally",
":",
"if",
"region",
":",
"dmtxRegionDestroy",
"(",
"byref",
"(",
"region",
")",... | A context manager for `DmtxRegion`, created and destroyed by
`dmtxRegionFindNext` and `dmtxRegionDestroy`.
Args:
decoder (POINTER(DmtxDecode)):
timeout (int or None):
Yields:
DmtxRegion: The next region or None, if all regions have been found. | [
"A",
"context",
"manager",
"for",
"DmtxRegion",
"created",
"and",
"destroyed",
"by",
"dmtxRegionFindNext",
"and",
"dmtxRegionDestroy",
"."
] | a425ec36050500af4875bf94eda02feb26ea62ad | https://github.com/NaturalHistoryMuseum/pylibdmtx/blob/a425ec36050500af4875bf94eda02feb26ea62ad/pylibdmtx/pylibdmtx.py#L109-L125 | train |
NaturalHistoryMuseum/pylibdmtx | pylibdmtx/pylibdmtx.py | _decoded_matrix_region | def _decoded_matrix_region(decoder, region, corrections):
"""A context manager for `DmtxMessage`, created and destoyed by
`dmtxDecodeMatrixRegion` and `dmtxMessageDestroy`.
Args:
decoder (POINTER(DmtxDecode)):
region (POINTER(DmtxRegion)):
corrections (int):
Yields:
DmtxMessage: The message.
"""
message = dmtxDecodeMatrixRegion(decoder, region, corrections)
try:
yield message
finally:
if message:
dmtxMessageDestroy(byref(message)) | python | def _decoded_matrix_region(decoder, region, corrections):
"""A context manager for `DmtxMessage`, created and destoyed by
`dmtxDecodeMatrixRegion` and `dmtxMessageDestroy`.
Args:
decoder (POINTER(DmtxDecode)):
region (POINTER(DmtxRegion)):
corrections (int):
Yields:
DmtxMessage: The message.
"""
message = dmtxDecodeMatrixRegion(decoder, region, corrections)
try:
yield message
finally:
if message:
dmtxMessageDestroy(byref(message)) | [
"def",
"_decoded_matrix_region",
"(",
"decoder",
",",
"region",
",",
"corrections",
")",
":",
"message",
"=",
"dmtxDecodeMatrixRegion",
"(",
"decoder",
",",
"region",
",",
"corrections",
")",
"try",
":",
"yield",
"message",
"finally",
":",
"if",
"message",
":"... | A context manager for `DmtxMessage`, created and destoyed by
`dmtxDecodeMatrixRegion` and `dmtxMessageDestroy`.
Args:
decoder (POINTER(DmtxDecode)):
region (POINTER(DmtxRegion)):
corrections (int):
Yields:
DmtxMessage: The message. | [
"A",
"context",
"manager",
"for",
"DmtxMessage",
"created",
"and",
"destoyed",
"by",
"dmtxDecodeMatrixRegion",
"and",
"dmtxMessageDestroy",
"."
] | a425ec36050500af4875bf94eda02feb26ea62ad | https://github.com/NaturalHistoryMuseum/pylibdmtx/blob/a425ec36050500af4875bf94eda02feb26ea62ad/pylibdmtx/pylibdmtx.py#L129-L146 | train |
NaturalHistoryMuseum/pylibdmtx | pylibdmtx/pylibdmtx.py | _decode_region | def _decode_region(decoder, region, corrections, shrink):
"""Decodes and returns the value in a region.
Args:
region (DmtxRegion):
Yields:
Decoded or None: The decoded value.
"""
with _decoded_matrix_region(decoder, region, corrections) as msg:
if msg:
# Coordinates
p00 = DmtxVector2()
p11 = DmtxVector2(1.0, 1.0)
dmtxMatrix3VMultiplyBy(
p00,
region.contents.fit2raw
)
dmtxMatrix3VMultiplyBy(p11, region.contents.fit2raw)
x0 = int((shrink * p00.X) + 0.5)
y0 = int((shrink * p00.Y) + 0.5)
x1 = int((shrink * p11.X) + 0.5)
y1 = int((shrink * p11.Y) + 0.5)
return Decoded(
string_at(msg.contents.output),
Rect(x0, y0, x1 - x0, y1 - y0)
)
else:
return None | python | def _decode_region(decoder, region, corrections, shrink):
"""Decodes and returns the value in a region.
Args:
region (DmtxRegion):
Yields:
Decoded or None: The decoded value.
"""
with _decoded_matrix_region(decoder, region, corrections) as msg:
if msg:
# Coordinates
p00 = DmtxVector2()
p11 = DmtxVector2(1.0, 1.0)
dmtxMatrix3VMultiplyBy(
p00,
region.contents.fit2raw
)
dmtxMatrix3VMultiplyBy(p11, region.contents.fit2raw)
x0 = int((shrink * p00.X) + 0.5)
y0 = int((shrink * p00.Y) + 0.5)
x1 = int((shrink * p11.X) + 0.5)
y1 = int((shrink * p11.Y) + 0.5)
return Decoded(
string_at(msg.contents.output),
Rect(x0, y0, x1 - x0, y1 - y0)
)
else:
return None | [
"def",
"_decode_region",
"(",
"decoder",
",",
"region",
",",
"corrections",
",",
"shrink",
")",
":",
"with",
"_decoded_matrix_region",
"(",
"decoder",
",",
"region",
",",
"corrections",
")",
"as",
"msg",
":",
"if",
"msg",
":",
"p00",
"=",
"DmtxVector2",
"(... | Decodes and returns the value in a region.
Args:
region (DmtxRegion):
Yields:
Decoded or None: The decoded value. | [
"Decodes",
"and",
"returns",
"the",
"value",
"in",
"a",
"region",
"."
] | a425ec36050500af4875bf94eda02feb26ea62ad | https://github.com/NaturalHistoryMuseum/pylibdmtx/blob/a425ec36050500af4875bf94eda02feb26ea62ad/pylibdmtx/pylibdmtx.py#L149-L177 | train |
NaturalHistoryMuseum/pylibdmtx | pylibdmtx/pylibdmtx.py | encode | def encode(data, scheme=None, size=None):
"""
Encodes `data` in a DataMatrix image.
For now bpp is the libdmtx default which is 24
Args:
data: bytes instance
scheme: encoding scheme - one of `ENCODING_SCHEME_NAMES`, or `None`.
If `None`, defaults to 'Ascii'.
size: image dimensions - one of `ENCODING_SIZE_NAMES`, or `None`.
If `None`, defaults to 'ShapeAuto'.
Returns:
Encoded: with properties `(width, height, bpp, pixels)`.
You can use that result to build a PIL image:
Image.frombytes('RGB', (width, height), pixels)
"""
size = size if size else 'ShapeAuto'
size_name = '{0}{1}'.format(ENCODING_SIZE_PREFIX, size)
if not hasattr(DmtxSymbolSize, size_name):
raise PyLibDMTXError(
'Invalid size [{0}]: should be one of {1}'.format(
size, ENCODING_SIZE_NAMES
)
)
size = getattr(DmtxSymbolSize, size_name)
scheme = scheme if scheme else 'Ascii'
scheme_name = '{0}{1}'.format(
ENCODING_SCHEME_PREFIX, scheme.capitalize()
)
if not hasattr(DmtxScheme, scheme_name):
raise PyLibDMTXError(
'Invalid scheme [{0}]: should be one of {1}'.format(
scheme, ENCODING_SCHEME_NAMES
)
)
scheme = getattr(DmtxScheme, scheme_name)
with _encoder() as encoder:
dmtxEncodeSetProp(encoder, DmtxProperty.DmtxPropScheme, scheme)
dmtxEncodeSetProp(encoder, DmtxProperty.DmtxPropSizeRequest, size)
if dmtxEncodeDataMatrix(encoder, len(data), cast(data, c_ubyte_p)) == 0:
raise PyLibDMTXError(
'Could not encode data, possibly because the image is not '
'large enough to contain the data'
)
w, h, bpp = map(
partial(dmtxImageGetProp, encoder[0].image),
(
DmtxProperty.DmtxPropWidth, DmtxProperty.DmtxPropHeight,
DmtxProperty.DmtxPropBitsPerPixel
)
)
size = w * h * bpp // 8
pixels = cast(
encoder[0].image[0].pxl, ctypes.POINTER(ctypes.c_ubyte * size)
)
return Encoded(
width=w, height=h, bpp=bpp, pixels=ctypes.string_at(pixels, size)
) | python | def encode(data, scheme=None, size=None):
"""
Encodes `data` in a DataMatrix image.
For now bpp is the libdmtx default which is 24
Args:
data: bytes instance
scheme: encoding scheme - one of `ENCODING_SCHEME_NAMES`, or `None`.
If `None`, defaults to 'Ascii'.
size: image dimensions - one of `ENCODING_SIZE_NAMES`, or `None`.
If `None`, defaults to 'ShapeAuto'.
Returns:
Encoded: with properties `(width, height, bpp, pixels)`.
You can use that result to build a PIL image:
Image.frombytes('RGB', (width, height), pixels)
"""
size = size if size else 'ShapeAuto'
size_name = '{0}{1}'.format(ENCODING_SIZE_PREFIX, size)
if not hasattr(DmtxSymbolSize, size_name):
raise PyLibDMTXError(
'Invalid size [{0}]: should be one of {1}'.format(
size, ENCODING_SIZE_NAMES
)
)
size = getattr(DmtxSymbolSize, size_name)
scheme = scheme if scheme else 'Ascii'
scheme_name = '{0}{1}'.format(
ENCODING_SCHEME_PREFIX, scheme.capitalize()
)
if not hasattr(DmtxScheme, scheme_name):
raise PyLibDMTXError(
'Invalid scheme [{0}]: should be one of {1}'.format(
scheme, ENCODING_SCHEME_NAMES
)
)
scheme = getattr(DmtxScheme, scheme_name)
with _encoder() as encoder:
dmtxEncodeSetProp(encoder, DmtxProperty.DmtxPropScheme, scheme)
dmtxEncodeSetProp(encoder, DmtxProperty.DmtxPropSizeRequest, size)
if dmtxEncodeDataMatrix(encoder, len(data), cast(data, c_ubyte_p)) == 0:
raise PyLibDMTXError(
'Could not encode data, possibly because the image is not '
'large enough to contain the data'
)
w, h, bpp = map(
partial(dmtxImageGetProp, encoder[0].image),
(
DmtxProperty.DmtxPropWidth, DmtxProperty.DmtxPropHeight,
DmtxProperty.DmtxPropBitsPerPixel
)
)
size = w * h * bpp // 8
pixels = cast(
encoder[0].image[0].pxl, ctypes.POINTER(ctypes.c_ubyte * size)
)
return Encoded(
width=w, height=h, bpp=bpp, pixels=ctypes.string_at(pixels, size)
) | [
"def",
"encode",
"(",
"data",
",",
"scheme",
"=",
"None",
",",
"size",
"=",
"None",
")",
":",
"size",
"=",
"size",
"if",
"size",
"else",
"'ShapeAuto'",
"size_name",
"=",
"'{0}{1}'",
".",
"format",
"(",
"ENCODING_SIZE_PREFIX",
",",
"size",
")",
"if",
"n... | Encodes `data` in a DataMatrix image.
For now bpp is the libdmtx default which is 24
Args:
data: bytes instance
scheme: encoding scheme - one of `ENCODING_SCHEME_NAMES`, or `None`.
If `None`, defaults to 'Ascii'.
size: image dimensions - one of `ENCODING_SIZE_NAMES`, or `None`.
If `None`, defaults to 'ShapeAuto'.
Returns:
Encoded: with properties `(width, height, bpp, pixels)`.
You can use that result to build a PIL image:
Image.frombytes('RGB', (width, height), pixels) | [
"Encodes",
"data",
"in",
"a",
"DataMatrix",
"image",
"."
] | a425ec36050500af4875bf94eda02feb26ea62ad | https://github.com/NaturalHistoryMuseum/pylibdmtx/blob/a425ec36050500af4875bf94eda02feb26ea62ad/pylibdmtx/pylibdmtx.py#L312-L378 | train |
GeoPyTool/GeoPyTool | Experimental/Alpah_Shape_2D.py | add_edge | def add_edge(edges, edge_points, coords, i, j):
"""
Add a line between the i-th and j-th points,
if not in the list already
"""
if (i, j) in edges or (j, i) in edges:
# already added
return( edges.add((i, j)), edge_points.append(coords[[i, j]])) | python | def add_edge(edges, edge_points, coords, i, j):
"""
Add a line between the i-th and j-th points,
if not in the list already
"""
if (i, j) in edges or (j, i) in edges:
# already added
return( edges.add((i, j)), edge_points.append(coords[[i, j]])) | [
"def",
"add_edge",
"(",
"edges",
",",
"edge_points",
",",
"coords",
",",
"i",
",",
"j",
")",
":",
"if",
"(",
"i",
",",
"j",
")",
"in",
"edges",
"or",
"(",
"j",
",",
"i",
")",
"in",
"edges",
":",
"return",
"(",
"edges",
".",
"add",
"(",
"(",
... | Add a line between the i-th and j-th points,
if not in the list already | [
"Add",
"a",
"line",
"between",
"the",
"i",
"-",
"th",
"and",
"j",
"-",
"th",
"points",
"if",
"not",
"in",
"the",
"list",
"already"
] | 8c198aa42e4fbdf62fac05d40cbf4d1086328da3 | https://github.com/GeoPyTool/GeoPyTool/blob/8c198aa42e4fbdf62fac05d40cbf4d1086328da3/Experimental/Alpah_Shape_2D.py#L28-L35 | train |
GeoPyTool/GeoPyTool | geopytool/CustomClass.py | Line.sequence | def sequence(self):
'''
sort the points in the line with given option
'''
if (len(self.Points[0]) == 2):
if (self.Sort == 'X' or self.Sort == 'x'):
self.Points.sort(key=lambda x: x[0])
self.order(self.Points)
elif (self.Sort == 'Y' or self.Sort == 'y'):
self.Points.sort(key=lambda x: x[1])
self.order(self.Points)
else:
self.order(self.Points)
if (len(self.Points[0]) == 3):
if (self.Sort == 'X' or self.Sort == 'x'):
self.Points.sort(key=lambda x: x[0])
self.order(self.Points)
elif (self.Sort == 'Y' or self.Sort == 'y'):
self.Points.sort(key=lambda x: x[1])
self.order(self.Points)
elif (self.Sort == 'Z' or self.Sort == 'Z'):
self.Points.sort(key=lambda x: x[2])
self.order(self.Points)
else:
self.order(self.Points) | python | def sequence(self):
'''
sort the points in the line with given option
'''
if (len(self.Points[0]) == 2):
if (self.Sort == 'X' or self.Sort == 'x'):
self.Points.sort(key=lambda x: x[0])
self.order(self.Points)
elif (self.Sort == 'Y' or self.Sort == 'y'):
self.Points.sort(key=lambda x: x[1])
self.order(self.Points)
else:
self.order(self.Points)
if (len(self.Points[0]) == 3):
if (self.Sort == 'X' or self.Sort == 'x'):
self.Points.sort(key=lambda x: x[0])
self.order(self.Points)
elif (self.Sort == 'Y' or self.Sort == 'y'):
self.Points.sort(key=lambda x: x[1])
self.order(self.Points)
elif (self.Sort == 'Z' or self.Sort == 'Z'):
self.Points.sort(key=lambda x: x[2])
self.order(self.Points)
else:
self.order(self.Points) | [
"def",
"sequence",
"(",
"self",
")",
":",
"if",
"(",
"len",
"(",
"self",
".",
"Points",
"[",
"0",
"]",
")",
"==",
"2",
")",
":",
"if",
"(",
"self",
".",
"Sort",
"==",
"'X'",
"or",
"self",
".",
"Sort",
"==",
"'x'",
")",
":",
"self",
".",
"Po... | sort the points in the line with given option | [
"sort",
"the",
"points",
"in",
"the",
"line",
"with",
"given",
"option"
] | 8c198aa42e4fbdf62fac05d40cbf4d1086328da3 | https://github.com/GeoPyTool/GeoPyTool/blob/8c198aa42e4fbdf62fac05d40cbf4d1086328da3/geopytool/CustomClass.py#L367-L394 | train |
HDI-Project/MLPrimitives | mlprimitives/adapters/pandas.py | resample | def resample(df, rule, time_index, groupby=None, aggregation='mean'):
"""pd.DataFrame.resample adapter.
Call the `df.resample` method on the given time_index
and afterwards call the indicated aggregation.
Optionally group the dataframe by the indicated columns before
performing the resampling.
If groupby option is used, the result is a multi-index datagrame.
Args:
df (pandas.DataFrame): DataFrame to resample.
rule (str): The offset string or object representing target conversion.
groupby (list): Optional list of columns to group by.
time_index (str): Name of the column to use as the time index.
aggregation (str): Name of the aggregation function to use.
Returns:
pandas.Dataframe: resampled dataframe
"""
if groupby:
df = df.groupby(groupby)
df = df.resample(rule, on=time_index)
df = getattr(df, aggregation)()
for column in groupby:
del df[column]
return df | python | def resample(df, rule, time_index, groupby=None, aggregation='mean'):
"""pd.DataFrame.resample adapter.
Call the `df.resample` method on the given time_index
and afterwards call the indicated aggregation.
Optionally group the dataframe by the indicated columns before
performing the resampling.
If groupby option is used, the result is a multi-index datagrame.
Args:
df (pandas.DataFrame): DataFrame to resample.
rule (str): The offset string or object representing target conversion.
groupby (list): Optional list of columns to group by.
time_index (str): Name of the column to use as the time index.
aggregation (str): Name of the aggregation function to use.
Returns:
pandas.Dataframe: resampled dataframe
"""
if groupby:
df = df.groupby(groupby)
df = df.resample(rule, on=time_index)
df = getattr(df, aggregation)()
for column in groupby:
del df[column]
return df | [
"def",
"resample",
"(",
"df",
",",
"rule",
",",
"time_index",
",",
"groupby",
"=",
"None",
",",
"aggregation",
"=",
"'mean'",
")",
":",
"if",
"groupby",
":",
"df",
"=",
"df",
".",
"groupby",
"(",
"groupby",
")",
"df",
"=",
"df",
".",
"resample",
"(... | pd.DataFrame.resample adapter.
Call the `df.resample` method on the given time_index
and afterwards call the indicated aggregation.
Optionally group the dataframe by the indicated columns before
performing the resampling.
If groupby option is used, the result is a multi-index datagrame.
Args:
df (pandas.DataFrame): DataFrame to resample.
rule (str): The offset string or object representing target conversion.
groupby (list): Optional list of columns to group by.
time_index (str): Name of the column to use as the time index.
aggregation (str): Name of the aggregation function to use.
Returns:
pandas.Dataframe: resampled dataframe | [
"pd",
".",
"DataFrame",
".",
"resample",
"adapter",
"."
] | bf415f9f751724ff545a1156ddfd7524e320f469 | https://github.com/HDI-Project/MLPrimitives/blob/bf415f9f751724ff545a1156ddfd7524e320f469/mlprimitives/adapters/pandas.py#L1-L30 | train |
HDI-Project/MLPrimitives | mlprimitives/adapters/pandas.py | _join_names | def _join_names(names):
"""Join the names of a multi-level index with an underscore."""
levels = (str(name) for name in names if name != '')
return '_'.join(levels) | python | def _join_names(names):
"""Join the names of a multi-level index with an underscore."""
levels = (str(name) for name in names if name != '')
return '_'.join(levels) | [
"def",
"_join_names",
"(",
"names",
")",
":",
"levels",
"=",
"(",
"str",
"(",
"name",
")",
"for",
"name",
"in",
"names",
"if",
"name",
"!=",
"''",
")",
"return",
"'_'",
".",
"join",
"(",
"levels",
")"
] | Join the names of a multi-level index with an underscore. | [
"Join",
"the",
"names",
"of",
"a",
"multi",
"-",
"level",
"index",
"with",
"an",
"underscore",
"."
] | bf415f9f751724ff545a1156ddfd7524e320f469 | https://github.com/HDI-Project/MLPrimitives/blob/bf415f9f751724ff545a1156ddfd7524e320f469/mlprimitives/adapters/pandas.py#L33-L37 | train |
HDI-Project/MLPrimitives | mlprimitives/adapters/pandas.py | unstack | def unstack(df, level=-1, reset_index=True):
"""pd.DataFrame.unstack adapter.
Call the `df.unstack` method using the indicated level and afterwards
join the column names using an underscore.
Args:
df (pandas.DataFrame): DataFrame to unstack.
level (str, int or list): Level(s) of index to unstack, can pass level name
reset_index (bool): Whether to reset the index after unstacking
Returns:
pandas.Dataframe: unstacked dataframe
"""
df = df.unstack(level=level)
if reset_index:
df = df.reset_index()
df.columns = df.columns.map(_join_names)
return df | python | def unstack(df, level=-1, reset_index=True):
"""pd.DataFrame.unstack adapter.
Call the `df.unstack` method using the indicated level and afterwards
join the column names using an underscore.
Args:
df (pandas.DataFrame): DataFrame to unstack.
level (str, int or list): Level(s) of index to unstack, can pass level name
reset_index (bool): Whether to reset the index after unstacking
Returns:
pandas.Dataframe: unstacked dataframe
"""
df = df.unstack(level=level)
if reset_index:
df = df.reset_index()
df.columns = df.columns.map(_join_names)
return df | [
"def",
"unstack",
"(",
"df",
",",
"level",
"=",
"-",
"1",
",",
"reset_index",
"=",
"True",
")",
":",
"df",
"=",
"df",
".",
"unstack",
"(",
"level",
"=",
"level",
")",
"if",
"reset_index",
":",
"df",
"=",
"df",
".",
"reset_index",
"(",
")",
"df",
... | pd.DataFrame.unstack adapter.
Call the `df.unstack` method using the indicated level and afterwards
join the column names using an underscore.
Args:
df (pandas.DataFrame): DataFrame to unstack.
level (str, int or list): Level(s) of index to unstack, can pass level name
reset_index (bool): Whether to reset the index after unstacking
Returns:
pandas.Dataframe: unstacked dataframe | [
"pd",
".",
"DataFrame",
".",
"unstack",
"adapter",
"."
] | bf415f9f751724ff545a1156ddfd7524e320f469 | https://github.com/HDI-Project/MLPrimitives/blob/bf415f9f751724ff545a1156ddfd7524e320f469/mlprimitives/adapters/pandas.py#L40-L59 | train |
HDI-Project/MLPrimitives | mlprimitives/datasets.py | load_boston_multitask | def load_boston_multitask():
"""Boston House Prices Dataset with a synthetic multitask output.
The multitask output is obtained by applying a linear transformation
to the original y and adding it as a second output column.
"""
dataset = datasets.load_boston()
y = dataset.target
target = np.column_stack([y, 2 * y + 5])
return Dataset(load_boston.__doc__, dataset.data, target, r2_score) | python | def load_boston_multitask():
"""Boston House Prices Dataset with a synthetic multitask output.
The multitask output is obtained by applying a linear transformation
to the original y and adding it as a second output column.
"""
dataset = datasets.load_boston()
y = dataset.target
target = np.column_stack([y, 2 * y + 5])
return Dataset(load_boston.__doc__, dataset.data, target, r2_score) | [
"def",
"load_boston_multitask",
"(",
")",
":",
"dataset",
"=",
"datasets",
".",
"load_boston",
"(",
")",
"y",
"=",
"dataset",
".",
"target",
"target",
"=",
"np",
".",
"column_stack",
"(",
"[",
"y",
",",
"2",
"*",
"y",
"+",
"5",
"]",
")",
"return",
... | Boston House Prices Dataset with a synthetic multitask output.
The multitask output is obtained by applying a linear transformation
to the original y and adding it as a second output column. | [
"Boston",
"House",
"Prices",
"Dataset",
"with",
"a",
"synthetic",
"multitask",
"output",
"."
] | bf415f9f751724ff545a1156ddfd7524e320f469 | https://github.com/HDI-Project/MLPrimitives/blob/bf415f9f751724ff545a1156ddfd7524e320f469/mlprimitives/datasets.py#L482-L491 | train |
HDI-Project/MLPrimitives | mlprimitives/candidates/audio_featurization.py | energy | def energy(data):
"""Computes signal energy of data"""
data = np.mean(data, axis=1)
return np.sum(data ** 2) / np.float64(len(data)) | python | def energy(data):
"""Computes signal energy of data"""
data = np.mean(data, axis=1)
return np.sum(data ** 2) / np.float64(len(data)) | [
"def",
"energy",
"(",
"data",
")",
":",
"data",
"=",
"np",
".",
"mean",
"(",
"data",
",",
"axis",
"=",
"1",
")",
"return",
"np",
".",
"sum",
"(",
"data",
"**",
"2",
")",
"/",
"np",
".",
"float64",
"(",
"len",
"(",
"data",
")",
")"
] | Computes signal energy of data | [
"Computes",
"signal",
"energy",
"of",
"data"
] | bf415f9f751724ff545a1156ddfd7524e320f469 | https://github.com/HDI-Project/MLPrimitives/blob/bf415f9f751724ff545a1156ddfd7524e320f469/mlprimitives/candidates/audio_featurization.py#L10-L13 | train |
HDI-Project/MLPrimitives | mlprimitives/candidates/audio_featurization.py | zcr | def zcr(data):
"""Computes zero crossing rate of segment"""
data = np.mean(data, axis=1)
count = len(data)
countZ = np.sum(np.abs(np.diff(np.sign(data)))) / 2
return (np.float64(countZ) / np.float64(count - 1.0)) | python | def zcr(data):
"""Computes zero crossing rate of segment"""
data = np.mean(data, axis=1)
count = len(data)
countZ = np.sum(np.abs(np.diff(np.sign(data)))) / 2
return (np.float64(countZ) / np.float64(count - 1.0)) | [
"def",
"zcr",
"(",
"data",
")",
":",
"data",
"=",
"np",
".",
"mean",
"(",
"data",
",",
"axis",
"=",
"1",
")",
"count",
"=",
"len",
"(",
"data",
")",
"countZ",
"=",
"np",
".",
"sum",
"(",
"np",
".",
"abs",
"(",
"np",
".",
"diff",
"(",
"np",
... | Computes zero crossing rate of segment | [
"Computes",
"zero",
"crossing",
"rate",
"of",
"segment"
] | bf415f9f751724ff545a1156ddfd7524e320f469 | https://github.com/HDI-Project/MLPrimitives/blob/bf415f9f751724ff545a1156ddfd7524e320f469/mlprimitives/candidates/audio_featurization.py#L51-L57 | train |
HDI-Project/MLPrimitives | mlprimitives/candidates/audio_featurization.py | spectral_flux | def spectral_flux(d0, d1):
"""
Computes the spectral flux feature of the current frame
"""
# compute the spectral flux as the sum of square distances:
d0 = np.mean(d0, axis=1)
d1 = np.mean(d1, axis=1)
nFFT = min(len(d0) // 2, len(d1) // 2)
X = FFT(d0, nFFT)
Xprev = FFT(d1, nFFT)
# L = min(len(X), len(Xprev))
sumX = np.sum(X + EPSILON)
sumPrevX = np.sum(Xprev + EPSILON)
return np.sum((X / sumX - Xprev / sumPrevX) ** 2) | python | def spectral_flux(d0, d1):
"""
Computes the spectral flux feature of the current frame
"""
# compute the spectral flux as the sum of square distances:
d0 = np.mean(d0, axis=1)
d1 = np.mean(d1, axis=1)
nFFT = min(len(d0) // 2, len(d1) // 2)
X = FFT(d0, nFFT)
Xprev = FFT(d1, nFFT)
# L = min(len(X), len(Xprev))
sumX = np.sum(X + EPSILON)
sumPrevX = np.sum(Xprev + EPSILON)
return np.sum((X / sumX - Xprev / sumPrevX) ** 2) | [
"def",
"spectral_flux",
"(",
"d0",
",",
"d1",
")",
":",
"d0",
"=",
"np",
".",
"mean",
"(",
"d0",
",",
"axis",
"=",
"1",
")",
"d1",
"=",
"np",
".",
"mean",
"(",
"d1",
",",
"axis",
"=",
"1",
")",
"nFFT",
"=",
"min",
"(",
"len",
"(",
"d0",
"... | Computes the spectral flux feature of the current frame | [
"Computes",
"the",
"spectral",
"flux",
"feature",
"of",
"the",
"current",
"frame"
] | bf415f9f751724ff545a1156ddfd7524e320f469 | https://github.com/HDI-Project/MLPrimitives/blob/bf415f9f751724ff545a1156ddfd7524e320f469/mlprimitives/candidates/audio_featurization.py#L60-L75 | train |
HDI-Project/MLPrimitives | mlprimitives/custom/timeseries_preprocessing.py | rolling_window_sequences | def rolling_window_sequences(X, index, window_size, target_size, target_column):
"""Create rolling window sequences out of timeseries data."""
out_X = list()
out_y = list()
X_index = list()
y_index = list()
target = X[:, target_column]
for start in range(len(X) - window_size - target_size + 1):
end = start + window_size
out_X.append(X[start:end])
out_y.append(target[end:end + target_size])
X_index.append(index[start])
y_index.append(index[end])
return np.asarray(out_X), np.asarray(out_y), np.asarray(X_index), np.asarray(y_index) | python | def rolling_window_sequences(X, index, window_size, target_size, target_column):
"""Create rolling window sequences out of timeseries data."""
out_X = list()
out_y = list()
X_index = list()
y_index = list()
target = X[:, target_column]
for start in range(len(X) - window_size - target_size + 1):
end = start + window_size
out_X.append(X[start:end])
out_y.append(target[end:end + target_size])
X_index.append(index[start])
y_index.append(index[end])
return np.asarray(out_X), np.asarray(out_y), np.asarray(X_index), np.asarray(y_index) | [
"def",
"rolling_window_sequences",
"(",
"X",
",",
"index",
",",
"window_size",
",",
"target_size",
",",
"target_column",
")",
":",
"out_X",
"=",
"list",
"(",
")",
"out_y",
"=",
"list",
"(",
")",
"X_index",
"=",
"list",
"(",
")",
"y_index",
"=",
"list",
... | Create rolling window sequences out of timeseries data. | [
"Create",
"rolling",
"window",
"sequences",
"out",
"of",
"timeseries",
"data",
"."
] | bf415f9f751724ff545a1156ddfd7524e320f469 | https://github.com/HDI-Project/MLPrimitives/blob/bf415f9f751724ff545a1156ddfd7524e320f469/mlprimitives/custom/timeseries_preprocessing.py#L7-L23 | train |
HDI-Project/MLPrimitives | mlprimitives/custom/timeseries_preprocessing.py | time_segments_average | def time_segments_average(X, interval, time_column):
"""Compute average of values over fixed length time segments."""
warnings.warn(_TIME_SEGMENTS_AVERAGE_DEPRECATION_WARNING, DeprecationWarning)
if isinstance(X, np.ndarray):
X = pd.DataFrame(X)
X = X.sort_values(time_column).set_index(time_column)
start_ts = X.index.values[0]
max_ts = X.index.values[-1]
values = list()
index = list()
while start_ts <= max_ts:
end_ts = start_ts + interval
subset = X.loc[start_ts:end_ts - 1]
means = subset.mean(skipna=True).values
values.append(means)
index.append(start_ts)
start_ts = end_ts
return np.asarray(values), np.asarray(index) | python | def time_segments_average(X, interval, time_column):
"""Compute average of values over fixed length time segments."""
warnings.warn(_TIME_SEGMENTS_AVERAGE_DEPRECATION_WARNING, DeprecationWarning)
if isinstance(X, np.ndarray):
X = pd.DataFrame(X)
X = X.sort_values(time_column).set_index(time_column)
start_ts = X.index.values[0]
max_ts = X.index.values[-1]
values = list()
index = list()
while start_ts <= max_ts:
end_ts = start_ts + interval
subset = X.loc[start_ts:end_ts - 1]
means = subset.mean(skipna=True).values
values.append(means)
index.append(start_ts)
start_ts = end_ts
return np.asarray(values), np.asarray(index) | [
"def",
"time_segments_average",
"(",
"X",
",",
"interval",
",",
"time_column",
")",
":",
"warnings",
".",
"warn",
"(",
"_TIME_SEGMENTS_AVERAGE_DEPRECATION_WARNING",
",",
"DeprecationWarning",
")",
"if",
"isinstance",
"(",
"X",
",",
"np",
".",
"ndarray",
")",
":"... | Compute average of values over fixed length time segments. | [
"Compute",
"average",
"of",
"values",
"over",
"fixed",
"length",
"time",
"segments",
"."
] | bf415f9f751724ff545a1156ddfd7524e320f469 | https://github.com/HDI-Project/MLPrimitives/blob/bf415f9f751724ff545a1156ddfd7524e320f469/mlprimitives/custom/timeseries_preprocessing.py#L33-L55 | train |
HDI-Project/MLPrimitives | mlprimitives/custom/timeseries_preprocessing.py | time_segments_aggregate | def time_segments_aggregate(X, interval, time_column, method=['mean']):
"""Aggregate values over fixed length time segments."""
if isinstance(X, np.ndarray):
X = pd.DataFrame(X)
X = X.sort_values(time_column).set_index(time_column)
if isinstance(method, str):
method = [method]
start_ts = X.index.values[0]
max_ts = X.index.values[-1]
values = list()
index = list()
while start_ts <= max_ts:
end_ts = start_ts + interval
subset = X.loc[start_ts:end_ts - 1]
aggregated = [
getattr(subset, agg)(skipna=True).values
for agg in method
]
values.append(np.concatenate(aggregated))
index.append(start_ts)
start_ts = end_ts
return np.asarray(values), np.asarray(index) | python | def time_segments_aggregate(X, interval, time_column, method=['mean']):
"""Aggregate values over fixed length time segments."""
if isinstance(X, np.ndarray):
X = pd.DataFrame(X)
X = X.sort_values(time_column).set_index(time_column)
if isinstance(method, str):
method = [method]
start_ts = X.index.values[0]
max_ts = X.index.values[-1]
values = list()
index = list()
while start_ts <= max_ts:
end_ts = start_ts + interval
subset = X.loc[start_ts:end_ts - 1]
aggregated = [
getattr(subset, agg)(skipna=True).values
for agg in method
]
values.append(np.concatenate(aggregated))
index.append(start_ts)
start_ts = end_ts
return np.asarray(values), np.asarray(index) | [
"def",
"time_segments_aggregate",
"(",
"X",
",",
"interval",
",",
"time_column",
",",
"method",
"=",
"[",
"'mean'",
"]",
")",
":",
"if",
"isinstance",
"(",
"X",
",",
"np",
".",
"ndarray",
")",
":",
"X",
"=",
"pd",
".",
"DataFrame",
"(",
"X",
")",
"... | Aggregate values over fixed length time segments. | [
"Aggregate",
"values",
"over",
"fixed",
"length",
"time",
"segments",
"."
] | bf415f9f751724ff545a1156ddfd7524e320f469 | https://github.com/HDI-Project/MLPrimitives/blob/bf415f9f751724ff545a1156ddfd7524e320f469/mlprimitives/custom/timeseries_preprocessing.py#L58-L84 | train |
HDI-Project/MLPrimitives | mlprimitives/utils.py | image_transform | def image_transform(X, function, reshape_before=False, reshape_after=False,
width=None, height=None, **kwargs):
"""Apply a function image by image.
Args:
reshape_before: whether 1d array needs to be reshaped to a 2d image
reshape_after: whether the returned values need to be reshaped back to a 1d array
width: image width used to rebuild the 2d images. Required if the image is not square.
height: image height used to rebuild the 2d images. Required if the image is not square.
"""
if not callable(function):
function = import_object(function)
elif not callable(function):
raise ValueError("function must be a str or a callable")
flat_image = len(X[0].shape) == 1
if reshape_before and flat_image:
if not (width and height):
side_length = math.sqrt(X.shape[1])
if side_length.is_integer():
side_length = int(side_length)
width = side_length
height = side_length
else:
raise ValueError("Image sizes must be given for non-square images")
else:
reshape_before = False
new_X = []
for image in X:
if reshape_before:
image = image.reshape((width, height))
features = function(
image,
**kwargs
)
if reshape_after:
features = np.reshape(features, X.shape[1])
new_X.append(features)
return np.array(new_X) | python | def image_transform(X, function, reshape_before=False, reshape_after=False,
width=None, height=None, **kwargs):
"""Apply a function image by image.
Args:
reshape_before: whether 1d array needs to be reshaped to a 2d image
reshape_after: whether the returned values need to be reshaped back to a 1d array
width: image width used to rebuild the 2d images. Required if the image is not square.
height: image height used to rebuild the 2d images. Required if the image is not square.
"""
if not callable(function):
function = import_object(function)
elif not callable(function):
raise ValueError("function must be a str or a callable")
flat_image = len(X[0].shape) == 1
if reshape_before and flat_image:
if not (width and height):
side_length = math.sqrt(X.shape[1])
if side_length.is_integer():
side_length = int(side_length)
width = side_length
height = side_length
else:
raise ValueError("Image sizes must be given for non-square images")
else:
reshape_before = False
new_X = []
for image in X:
if reshape_before:
image = image.reshape((width, height))
features = function(
image,
**kwargs
)
if reshape_after:
features = np.reshape(features, X.shape[1])
new_X.append(features)
return np.array(new_X) | [
"def",
"image_transform",
"(",
"X",
",",
"function",
",",
"reshape_before",
"=",
"False",
",",
"reshape_after",
"=",
"False",
",",
"width",
"=",
"None",
",",
"height",
"=",
"None",
",",
"**",
"kwargs",
")",
":",
"if",
"not",
"callable",
"(",
"function",
... | Apply a function image by image.
Args:
reshape_before: whether 1d array needs to be reshaped to a 2d image
reshape_after: whether the returned values need to be reshaped back to a 1d array
width: image width used to rebuild the 2d images. Required if the image is not square.
height: image height used to rebuild the 2d images. Required if the image is not square. | [
"Apply",
"a",
"function",
"image",
"by",
"image",
"."
] | bf415f9f751724ff545a1156ddfd7524e320f469 | https://github.com/HDI-Project/MLPrimitives/blob/bf415f9f751724ff545a1156ddfd7524e320f469/mlprimitives/utils.py#L18-L65 | train |
HDI-Project/MLPrimitives | mlprimitives/custom/timeseries_anomalies.py | regression_errors | def regression_errors(y, y_hat, smoothing_window=0.01, smooth=True):
"""Compute an array of absolute errors comparing predictions and expected output.
If smooth is True, apply EWMA to the resulting array of errors.
Args:
y (array): Ground truth.
y_hat (array): Predictions array.
smoothing_window (float): Size of the smoothing window, expressed as a proportion
of the total length of y.
smooth (bool): whether the returned errors should be smoothed with EWMA.
Returns:
(array): errors
"""
errors = np.abs(y - y_hat)[:, 0]
if not smooth:
return errors
smoothing_window = int(smoothing_window * len(y))
return pd.Series(errors).ewm(span=smoothing_window).mean().values | python | def regression_errors(y, y_hat, smoothing_window=0.01, smooth=True):
"""Compute an array of absolute errors comparing predictions and expected output.
If smooth is True, apply EWMA to the resulting array of errors.
Args:
y (array): Ground truth.
y_hat (array): Predictions array.
smoothing_window (float): Size of the smoothing window, expressed as a proportion
of the total length of y.
smooth (bool): whether the returned errors should be smoothed with EWMA.
Returns:
(array): errors
"""
errors = np.abs(y - y_hat)[:, 0]
if not smooth:
return errors
smoothing_window = int(smoothing_window * len(y))
return pd.Series(errors).ewm(span=smoothing_window).mean().values | [
"def",
"regression_errors",
"(",
"y",
",",
"y_hat",
",",
"smoothing_window",
"=",
"0.01",
",",
"smooth",
"=",
"True",
")",
":",
"errors",
"=",
"np",
".",
"abs",
"(",
"y",
"-",
"y_hat",
")",
"[",
":",
",",
"0",
"]",
"if",
"not",
"smooth",
":",
"re... | Compute an array of absolute errors comparing predictions and expected output.
If smooth is True, apply EWMA to the resulting array of errors.
Args:
y (array): Ground truth.
y_hat (array): Predictions array.
smoothing_window (float): Size of the smoothing window, expressed as a proportion
of the total length of y.
smooth (bool): whether the returned errors should be smoothed with EWMA.
Returns:
(array): errors | [
"Compute",
"an",
"array",
"of",
"absolute",
"errors",
"comparing",
"predictions",
"and",
"expected",
"output",
"."
] | bf415f9f751724ff545a1156ddfd7524e320f469 | https://github.com/HDI-Project/MLPrimitives/blob/bf415f9f751724ff545a1156ddfd7524e320f469/mlprimitives/custom/timeseries_anomalies.py#L11-L33 | train |
HDI-Project/MLPrimitives | mlprimitives/custom/timeseries_anomalies.py | deltas | def deltas(errors, epsilon, mean, std):
"""Compute mean and std deltas.
delta_mean = mean(errors) - mean(all errors below epsilon)
delta_std = std(errors) - std(all errors below epsilon)
"""
below = errors[errors <= epsilon]
if not len(below):
return 0, 0
return mean - below.mean(), std - below.std() | python | def deltas(errors, epsilon, mean, std):
"""Compute mean and std deltas.
delta_mean = mean(errors) - mean(all errors below epsilon)
delta_std = std(errors) - std(all errors below epsilon)
"""
below = errors[errors <= epsilon]
if not len(below):
return 0, 0
return mean - below.mean(), std - below.std() | [
"def",
"deltas",
"(",
"errors",
",",
"epsilon",
",",
"mean",
",",
"std",
")",
":",
"below",
"=",
"errors",
"[",
"errors",
"<=",
"epsilon",
"]",
"if",
"not",
"len",
"(",
"below",
")",
":",
"return",
"0",
",",
"0",
"return",
"mean",
"-",
"below",
"... | Compute mean and std deltas.
delta_mean = mean(errors) - mean(all errors below epsilon)
delta_std = std(errors) - std(all errors below epsilon) | [
"Compute",
"mean",
"and",
"std",
"deltas",
"."
] | bf415f9f751724ff545a1156ddfd7524e320f469 | https://github.com/HDI-Project/MLPrimitives/blob/bf415f9f751724ff545a1156ddfd7524e320f469/mlprimitives/custom/timeseries_anomalies.py#L36-L46 | train |
HDI-Project/MLPrimitives | mlprimitives/custom/timeseries_anomalies.py | count_above | def count_above(errors, epsilon):
"""Count number of errors and continuous sequences above epsilon.
Continuous sequences are counted by shifting and counting the number
of positions where there was a change and the original value was true,
which means that a sequence started at that position.
"""
above = errors > epsilon
total_above = len(errors[above])
above = pd.Series(above)
shift = above.shift(1)
change = above != shift
total_consecutive = sum(above & change)
return total_above, total_consecutive | python | def count_above(errors, epsilon):
"""Count number of errors and continuous sequences above epsilon.
Continuous sequences are counted by shifting and counting the number
of positions where there was a change and the original value was true,
which means that a sequence started at that position.
"""
above = errors > epsilon
total_above = len(errors[above])
above = pd.Series(above)
shift = above.shift(1)
change = above != shift
total_consecutive = sum(above & change)
return total_above, total_consecutive | [
"def",
"count_above",
"(",
"errors",
",",
"epsilon",
")",
":",
"above",
"=",
"errors",
">",
"epsilon",
"total_above",
"=",
"len",
"(",
"errors",
"[",
"above",
"]",
")",
"above",
"=",
"pd",
".",
"Series",
"(",
"above",
")",
"shift",
"=",
"above",
".",... | Count number of errors and continuous sequences above epsilon.
Continuous sequences are counted by shifting and counting the number
of positions where there was a change and the original value was true,
which means that a sequence started at that position. | [
"Count",
"number",
"of",
"errors",
"and",
"continuous",
"sequences",
"above",
"epsilon",
"."
] | bf415f9f751724ff545a1156ddfd7524e320f469 | https://github.com/HDI-Project/MLPrimitives/blob/bf415f9f751724ff545a1156ddfd7524e320f469/mlprimitives/custom/timeseries_anomalies.py#L49-L65 | train |
HDI-Project/MLPrimitives | mlprimitives/custom/timeseries_anomalies.py | z_cost | def z_cost(z, errors, mean, std):
"""Compute how bad a z value is.
The original formula is::
(delta_mean/mean) + (delta_std/std)
------------------------------------------------------
number of errors above + (number of sequences above)^2
which computes the "goodness" of `z`, meaning that the higher the value
the better the `z`.
In this case, we return this value inverted (we make it negative), to convert
it into a cost function, as later on we will use scipy to minimize it.
"""
epsilon = mean + z * std
delta_mean, delta_std = deltas(errors, epsilon, mean, std)
above, consecutive = count_above(errors, epsilon)
numerator = -(delta_mean / mean + delta_std / std)
denominator = above + consecutive ** 2
if denominator == 0:
return np.inf
return numerator / denominator | python | def z_cost(z, errors, mean, std):
"""Compute how bad a z value is.
The original formula is::
(delta_mean/mean) + (delta_std/std)
------------------------------------------------------
number of errors above + (number of sequences above)^2
which computes the "goodness" of `z`, meaning that the higher the value
the better the `z`.
In this case, we return this value inverted (we make it negative), to convert
it into a cost function, as later on we will use scipy to minimize it.
"""
epsilon = mean + z * std
delta_mean, delta_std = deltas(errors, epsilon, mean, std)
above, consecutive = count_above(errors, epsilon)
numerator = -(delta_mean / mean + delta_std / std)
denominator = above + consecutive ** 2
if denominator == 0:
return np.inf
return numerator / denominator | [
"def",
"z_cost",
"(",
"z",
",",
"errors",
",",
"mean",
",",
"std",
")",
":",
"epsilon",
"=",
"mean",
"+",
"z",
"*",
"std",
"delta_mean",
",",
"delta_std",
"=",
"deltas",
"(",
"errors",
",",
"epsilon",
",",
"mean",
",",
"std",
")",
"above",
",",
"... | Compute how bad a z value is.
The original formula is::
(delta_mean/mean) + (delta_std/std)
------------------------------------------------------
number of errors above + (number of sequences above)^2
which computes the "goodness" of `z`, meaning that the higher the value
the better the `z`.
In this case, we return this value inverted (we make it negative), to convert
it into a cost function, as later on we will use scipy to minimize it. | [
"Compute",
"how",
"bad",
"a",
"z",
"value",
"is",
"."
] | bf415f9f751724ff545a1156ddfd7524e320f469 | https://github.com/HDI-Project/MLPrimitives/blob/bf415f9f751724ff545a1156ddfd7524e320f469/mlprimitives/custom/timeseries_anomalies.py#L68-L95 | train |
HDI-Project/MLPrimitives | mlprimitives/custom/timeseries_anomalies.py | find_threshold | def find_threshold(errors, z_range=(0, 10)):
"""Find the ideal threshold.
The ideal threshold is the one that minimizes the z_cost function.
"""
mean = errors.mean()
std = errors.std()
min_z, max_z = z_range
best_z = min_z
best_cost = np.inf
for z in range(min_z, max_z):
best = fmin(z_cost, z, args=(errors, mean, std), full_output=True, disp=False)
z, cost = best[0:2]
if cost < best_cost:
best_z = z[0]
return mean + best_z * std | python | def find_threshold(errors, z_range=(0, 10)):
"""Find the ideal threshold.
The ideal threshold is the one that minimizes the z_cost function.
"""
mean = errors.mean()
std = errors.std()
min_z, max_z = z_range
best_z = min_z
best_cost = np.inf
for z in range(min_z, max_z):
best = fmin(z_cost, z, args=(errors, mean, std), full_output=True, disp=False)
z, cost = best[0:2]
if cost < best_cost:
best_z = z[0]
return mean + best_z * std | [
"def",
"find_threshold",
"(",
"errors",
",",
"z_range",
"=",
"(",
"0",
",",
"10",
")",
")",
":",
"mean",
"=",
"errors",
".",
"mean",
"(",
")",
"std",
"=",
"errors",
".",
"std",
"(",
")",
"min_z",
",",
"max_z",
"=",
"z_range",
"best_z",
"=",
"min_... | Find the ideal threshold.
The ideal threshold is the one that minimizes the z_cost function. | [
"Find",
"the",
"ideal",
"threshold",
"."
] | bf415f9f751724ff545a1156ddfd7524e320f469 | https://github.com/HDI-Project/MLPrimitives/blob/bf415f9f751724ff545a1156ddfd7524e320f469/mlprimitives/custom/timeseries_anomalies.py#L98-L116 | train |
HDI-Project/MLPrimitives | mlprimitives/custom/timeseries_anomalies.py | find_sequences | def find_sequences(errors, epsilon):
"""Find sequences of values that are above epsilon.
This is done following this steps:
* create a boolean mask that indicates which value are above epsilon.
* shift this mask by one place, filing the empty gap with a False
* compare the shifted mask with the original one to see if there are changes.
* Consider a sequence start any point which was true and has changed
* Consider a sequence end any point which was false and has changed
"""
above = pd.Series(errors > epsilon)
shift = above.shift(1).fillna(False)
change = above != shift
index = above.index
starts = index[above & change].tolist()
ends = (index[~above & change] - 1).tolist()
if len(ends) == len(starts) - 1:
ends.append(len(above) - 1)
return list(zip(starts, ends)) | python | def find_sequences(errors, epsilon):
"""Find sequences of values that are above epsilon.
This is done following this steps:
* create a boolean mask that indicates which value are above epsilon.
* shift this mask by one place, filing the empty gap with a False
* compare the shifted mask with the original one to see if there are changes.
* Consider a sequence start any point which was true and has changed
* Consider a sequence end any point which was false and has changed
"""
above = pd.Series(errors > epsilon)
shift = above.shift(1).fillna(False)
change = above != shift
index = above.index
starts = index[above & change].tolist()
ends = (index[~above & change] - 1).tolist()
if len(ends) == len(starts) - 1:
ends.append(len(above) - 1)
return list(zip(starts, ends)) | [
"def",
"find_sequences",
"(",
"errors",
",",
"epsilon",
")",
":",
"above",
"=",
"pd",
".",
"Series",
"(",
"errors",
">",
"epsilon",
")",
"shift",
"=",
"above",
".",
"shift",
"(",
"1",
")",
".",
"fillna",
"(",
"False",
")",
"change",
"=",
"above",
"... | Find sequences of values that are above epsilon.
This is done following this steps:
* create a boolean mask that indicates which value are above epsilon.
* shift this mask by one place, filing the empty gap with a False
* compare the shifted mask with the original one to see if there are changes.
* Consider a sequence start any point which was true and has changed
* Consider a sequence end any point which was false and has changed | [
"Find",
"sequences",
"of",
"values",
"that",
"are",
"above",
"epsilon",
"."
] | bf415f9f751724ff545a1156ddfd7524e320f469 | https://github.com/HDI-Project/MLPrimitives/blob/bf415f9f751724ff545a1156ddfd7524e320f469/mlprimitives/custom/timeseries_anomalies.py#L119-L140 | train |
HDI-Project/MLPrimitives | mlprimitives/custom/timeseries_anomalies.py | find_anomalies | def find_anomalies(errors, index, z_range=(0, 10)):
"""Find sequences of values that are anomalous.
We first find the ideal threshold for the set of errors that we have,
and then find the sequences of values that are above this threshold.
Lastly, we compute a score proportional to the maximum error in the
sequence, and finally return the index pairs that correspond to
each sequence, along with its score.
"""
threshold = find_threshold(errors, z_range)
sequences = find_sequences(errors, threshold)
anomalies = list()
denominator = errors.mean() + errors.std()
for start, stop in sequences:
max_error = errors[start:stop + 1].max()
score = (max_error - threshold) / denominator
anomalies.append([index[start], index[stop], score])
return np.asarray(anomalies) | python | def find_anomalies(errors, index, z_range=(0, 10)):
"""Find sequences of values that are anomalous.
We first find the ideal threshold for the set of errors that we have,
and then find the sequences of values that are above this threshold.
Lastly, we compute a score proportional to the maximum error in the
sequence, and finally return the index pairs that correspond to
each sequence, along with its score.
"""
threshold = find_threshold(errors, z_range)
sequences = find_sequences(errors, threshold)
anomalies = list()
denominator = errors.mean() + errors.std()
for start, stop in sequences:
max_error = errors[start:stop + 1].max()
score = (max_error - threshold) / denominator
anomalies.append([index[start], index[stop], score])
return np.asarray(anomalies) | [
"def",
"find_anomalies",
"(",
"errors",
",",
"index",
",",
"z_range",
"=",
"(",
"0",
",",
"10",
")",
")",
":",
"threshold",
"=",
"find_threshold",
"(",
"errors",
",",
"z_range",
")",
"sequences",
"=",
"find_sequences",
"(",
"errors",
",",
"threshold",
")... | Find sequences of values that are anomalous.
We first find the ideal threshold for the set of errors that we have,
and then find the sequences of values that are above this threshold.
Lastly, we compute a score proportional to the maximum error in the
sequence, and finally return the index pairs that correspond to
each sequence, along with its score. | [
"Find",
"sequences",
"of",
"values",
"that",
"are",
"anomalous",
"."
] | bf415f9f751724ff545a1156ddfd7524e320f469 | https://github.com/HDI-Project/MLPrimitives/blob/bf415f9f751724ff545a1156ddfd7524e320f469/mlprimitives/custom/timeseries_anomalies.py#L143-L164 | train |
HDI-Project/MLPrimitives | mlprimitives/adapters/cv2.py | GaussianBlur | def GaussianBlur(X, ksize_width, ksize_height, sigma_x, sigma_y):
"""Apply Gaussian blur to the given data.
Args:
X: data to blur
kernel_size: Gaussian kernel size
stddev: Gaussian kernel standard deviation (in both X and Y directions)
"""
return image_transform(
X,
cv2.GaussianBlur,
ksize=(ksize_width, ksize_height),
sigmaX=sigma_x,
sigmaY=sigma_y
) | python | def GaussianBlur(X, ksize_width, ksize_height, sigma_x, sigma_y):
"""Apply Gaussian blur to the given data.
Args:
X: data to blur
kernel_size: Gaussian kernel size
stddev: Gaussian kernel standard deviation (in both X and Y directions)
"""
return image_transform(
X,
cv2.GaussianBlur,
ksize=(ksize_width, ksize_height),
sigmaX=sigma_x,
sigmaY=sigma_y
) | [
"def",
"GaussianBlur",
"(",
"X",
",",
"ksize_width",
",",
"ksize_height",
",",
"sigma_x",
",",
"sigma_y",
")",
":",
"return",
"image_transform",
"(",
"X",
",",
"cv2",
".",
"GaussianBlur",
",",
"ksize",
"=",
"(",
"ksize_width",
",",
"ksize_height",
")",
","... | Apply Gaussian blur to the given data.
Args:
X: data to blur
kernel_size: Gaussian kernel size
stddev: Gaussian kernel standard deviation (in both X and Y directions) | [
"Apply",
"Gaussian",
"blur",
"to",
"the",
"given",
"data",
"."
] | bf415f9f751724ff545a1156ddfd7524e320f469 | https://github.com/HDI-Project/MLPrimitives/blob/bf415f9f751724ff545a1156ddfd7524e320f469/mlprimitives/adapters/cv2.py#L8-L22 | train |
HDI-Project/MLPrimitives | mlprimitives/candidates/timeseries_errors.py | get_anomalies | def get_anomalies(smoothed_errors, y_true, z, window, all_anomalies, error_buffer):
"""
Helper method to get anomalies.
"""
mu = np.mean(smoothed_errors)
sigma = np.std(smoothed_errors)
epsilon = mu + (z * sigma)
# compare to epsilon
errors_seq, anomaly_indices, max_error_below_e = group_consecutive_anomalies(
smoothed_errors,
epsilon,
y_true,
error_buffer,
window,
all_anomalies
)
if len(errors_seq) > 0:
anomaly_indices = prune_anomalies(
errors_seq,
smoothed_errors,
max_error_below_e,
anomaly_indices
)
return anomaly_indices | python | def get_anomalies(smoothed_errors, y_true, z, window, all_anomalies, error_buffer):
"""
Helper method to get anomalies.
"""
mu = np.mean(smoothed_errors)
sigma = np.std(smoothed_errors)
epsilon = mu + (z * sigma)
# compare to epsilon
errors_seq, anomaly_indices, max_error_below_e = group_consecutive_anomalies(
smoothed_errors,
epsilon,
y_true,
error_buffer,
window,
all_anomalies
)
if len(errors_seq) > 0:
anomaly_indices = prune_anomalies(
errors_seq,
smoothed_errors,
max_error_below_e,
anomaly_indices
)
return anomaly_indices | [
"def",
"get_anomalies",
"(",
"smoothed_errors",
",",
"y_true",
",",
"z",
",",
"window",
",",
"all_anomalies",
",",
"error_buffer",
")",
":",
"mu",
"=",
"np",
".",
"mean",
"(",
"smoothed_errors",
")",
"sigma",
"=",
"np",
".",
"std",
"(",
"smoothed_errors",
... | Helper method to get anomalies. | [
"Helper",
"method",
"to",
"get",
"anomalies",
"."
] | bf415f9f751724ff545a1156ddfd7524e320f469 | https://github.com/HDI-Project/MLPrimitives/blob/bf415f9f751724ff545a1156ddfd7524e320f469/mlprimitives/candidates/timeseries_errors.py#L186-L214 | train |
HDI-Project/MLPrimitives | mlprimitives/candidates/timeseries_errors.py | prune_anomalies | def prune_anomalies(e_seq, smoothed_errors, max_error_below_e, anomaly_indices):
""" Helper method that removes anomalies which don't meet
a minimum separation from next anomaly.
"""
# min accepted perc decrease btwn max errors in anomalous sequences
MIN_PERCENT_DECREASE = 0.05
e_seq_max, smoothed_errors_max = [], []
for error_seq in e_seq:
if len(smoothed_errors[error_seq[0]:error_seq[1]]) > 0:
sliced_errors = smoothed_errors[error_seq[0]:error_seq[1]]
e_seq_max.append(max(sliced_errors))
smoothed_errors_max.append(max(sliced_errors))
smoothed_errors_max.sort(reverse=True)
if max_error_below_e > 0:
smoothed_errors_max.append(max_error_below_e)
indices_remove = []
for i in range(len(smoothed_errors_max)):
if i < len(smoothed_errors_max) - 1:
delta = smoothed_errors_max[i] - smoothed_errors_max[i + 1]
perc_change = delta / smoothed_errors_max[i]
if perc_change < MIN_PERCENT_DECREASE:
indices_remove.append(e_seq_max.index(smoothed_errors_max[i]))
for index in sorted(indices_remove, reverse=True):
del e_seq[index]
pruned_indices = []
for i in anomaly_indices:
for error_seq in e_seq:
if i >= error_seq[0] and i <= error_seq[1]:
pruned_indices.append(i)
return pruned_indices | python | def prune_anomalies(e_seq, smoothed_errors, max_error_below_e, anomaly_indices):
""" Helper method that removes anomalies which don't meet
a minimum separation from next anomaly.
"""
# min accepted perc decrease btwn max errors in anomalous sequences
MIN_PERCENT_DECREASE = 0.05
e_seq_max, smoothed_errors_max = [], []
for error_seq in e_seq:
if len(smoothed_errors[error_seq[0]:error_seq[1]]) > 0:
sliced_errors = smoothed_errors[error_seq[0]:error_seq[1]]
e_seq_max.append(max(sliced_errors))
smoothed_errors_max.append(max(sliced_errors))
smoothed_errors_max.sort(reverse=True)
if max_error_below_e > 0:
smoothed_errors_max.append(max_error_below_e)
indices_remove = []
for i in range(len(smoothed_errors_max)):
if i < len(smoothed_errors_max) - 1:
delta = smoothed_errors_max[i] - smoothed_errors_max[i + 1]
perc_change = delta / smoothed_errors_max[i]
if perc_change < MIN_PERCENT_DECREASE:
indices_remove.append(e_seq_max.index(smoothed_errors_max[i]))
for index in sorted(indices_remove, reverse=True):
del e_seq[index]
pruned_indices = []
for i in anomaly_indices:
for error_seq in e_seq:
if i >= error_seq[0] and i <= error_seq[1]:
pruned_indices.append(i)
return pruned_indices | [
"def",
"prune_anomalies",
"(",
"e_seq",
",",
"smoothed_errors",
",",
"max_error_below_e",
",",
"anomaly_indices",
")",
":",
"MIN_PERCENT_DECREASE",
"=",
"0.05",
"e_seq_max",
",",
"smoothed_errors_max",
"=",
"[",
"]",
",",
"[",
"]",
"for",
"error_seq",
"in",
"e_s... | Helper method that removes anomalies which don't meet
a minimum separation from next anomaly. | [
"Helper",
"method",
"that",
"removes",
"anomalies",
"which",
"don",
"t",
"meet",
"a",
"minimum",
"separation",
"from",
"next",
"anomaly",
"."
] | bf415f9f751724ff545a1156ddfd7524e320f469 | https://github.com/HDI-Project/MLPrimitives/blob/bf415f9f751724ff545a1156ddfd7524e320f469/mlprimitives/candidates/timeseries_errors.py#L262-L299 | train |
ultrabug/uhashring | uhashring/ring.py | HashRing._configure_nodes | def _configure_nodes(self, nodes):
"""Parse and set up the given nodes.
:param nodes: nodes used to create the continuum (see doc for format).
"""
if isinstance(nodes, str):
nodes = [nodes]
elif not isinstance(nodes, (dict, list)):
raise ValueError(
'nodes configuration should be a list or a dict,'
' got {}'.format(type(nodes)))
conf_changed = False
for node in nodes:
conf = {
'hostname': node,
'instance': None,
'nodename': node,
'port': None,
'vnodes': self._default_vnodes,
'weight': 1
}
current_conf = self.runtime._nodes.get(node, {})
nodename = node
# new node, trigger a ring update
if not current_conf:
conf_changed = True
# complex config
if isinstance(nodes, dict):
node_conf = nodes[node]
if isinstance(node_conf, int):
conf['weight'] = node_conf
elif isinstance(node_conf, dict):
for k, v in node_conf.items():
if k in conf:
conf[k] = v
# changing those config trigger a ring update
if k in ['nodename', 'vnodes', 'weight']:
if current_conf.get(k) != v:
conf_changed = True
else:
raise ValueError(
'node configuration should be a dict or an int,'
' got {}'.format(type(node_conf)))
if self._weight_fn:
conf['weight'] = self._weight_fn(**conf)
# changing the weight of a node trigger a ring update
if current_conf.get('weight') != conf['weight']:
conf_changed = True
self.runtime._nodes[nodename] = conf
return conf_changed | python | def _configure_nodes(self, nodes):
"""Parse and set up the given nodes.
:param nodes: nodes used to create the continuum (see doc for format).
"""
if isinstance(nodes, str):
nodes = [nodes]
elif not isinstance(nodes, (dict, list)):
raise ValueError(
'nodes configuration should be a list or a dict,'
' got {}'.format(type(nodes)))
conf_changed = False
for node in nodes:
conf = {
'hostname': node,
'instance': None,
'nodename': node,
'port': None,
'vnodes': self._default_vnodes,
'weight': 1
}
current_conf = self.runtime._nodes.get(node, {})
nodename = node
# new node, trigger a ring update
if not current_conf:
conf_changed = True
# complex config
if isinstance(nodes, dict):
node_conf = nodes[node]
if isinstance(node_conf, int):
conf['weight'] = node_conf
elif isinstance(node_conf, dict):
for k, v in node_conf.items():
if k in conf:
conf[k] = v
# changing those config trigger a ring update
if k in ['nodename', 'vnodes', 'weight']:
if current_conf.get(k) != v:
conf_changed = True
else:
raise ValueError(
'node configuration should be a dict or an int,'
' got {}'.format(type(node_conf)))
if self._weight_fn:
conf['weight'] = self._weight_fn(**conf)
# changing the weight of a node trigger a ring update
if current_conf.get('weight') != conf['weight']:
conf_changed = True
self.runtime._nodes[nodename] = conf
return conf_changed | [
"def",
"_configure_nodes",
"(",
"self",
",",
"nodes",
")",
":",
"if",
"isinstance",
"(",
"nodes",
",",
"str",
")",
":",
"nodes",
"=",
"[",
"nodes",
"]",
"elif",
"not",
"isinstance",
"(",
"nodes",
",",
"(",
"dict",
",",
"list",
")",
")",
":",
"raise... | Parse and set up the given nodes.
:param nodes: nodes used to create the continuum (see doc for format). | [
"Parse",
"and",
"set",
"up",
"the",
"given",
"nodes",
"."
] | 2297471a392e28ed913b3276c2f48d0c01523375 | https://github.com/ultrabug/uhashring/blob/2297471a392e28ed913b3276c2f48d0c01523375/uhashring/ring.py#L44-L94 | train |
ultrabug/uhashring | uhashring/ring.py | HashRing._get_pos | def _get_pos(self, key):
"""Get the index of the given key in the sorted key list.
We return the position with the nearest hash based on
the provided key unless we reach the end of the continuum/ring
in which case we return the 0 (beginning) index position.
:param key: the key to hash and look for.
"""
p = bisect(self.runtime._keys, self.hashi(key))
if p == len(self.runtime._keys):
return 0
else:
return p | python | def _get_pos(self, key):
"""Get the index of the given key in the sorted key list.
We return the position with the nearest hash based on
the provided key unless we reach the end of the continuum/ring
in which case we return the 0 (beginning) index position.
:param key: the key to hash and look for.
"""
p = bisect(self.runtime._keys, self.hashi(key))
if p == len(self.runtime._keys):
return 0
else:
return p | [
"def",
"_get_pos",
"(",
"self",
",",
"key",
")",
":",
"p",
"=",
"bisect",
"(",
"self",
".",
"runtime",
".",
"_keys",
",",
"self",
".",
"hashi",
"(",
"key",
")",
")",
"if",
"p",
"==",
"len",
"(",
"self",
".",
"runtime",
".",
"_keys",
")",
":",
... | Get the index of the given key in the sorted key list.
We return the position with the nearest hash based on
the provided key unless we reach the end of the continuum/ring
in which case we return the 0 (beginning) index position.
:param key: the key to hash and look for. | [
"Get",
"the",
"index",
"of",
"the",
"given",
"key",
"in",
"the",
"sorted",
"key",
"list",
"."
] | 2297471a392e28ed913b3276c2f48d0c01523375 | https://github.com/ultrabug/uhashring/blob/2297471a392e28ed913b3276c2f48d0c01523375/uhashring/ring.py#L125-L138 | train |
ultrabug/uhashring | uhashring/ring.py | HashRing._get | def _get(self, key, what):
"""Generic getter magic method.
The node with the nearest but not less hash value is returned.
:param key: the key to look for.
:param what: the information to look for in, allowed values:
- instance (default): associated node instance
- nodename: node name
- pos: index of the given key in the ring
- tuple: ketama compatible (pos, name) tuple
- weight: node weight
"""
if not self.runtime._ring:
return None
pos = self._get_pos(key)
if what == 'pos':
return pos
nodename = self.runtime._ring[self.runtime._keys[pos]]
if what in ['hostname', 'instance', 'port', 'weight']:
return self.runtime._nodes[nodename][what]
elif what == 'dict':
return self.runtime._nodes[nodename]
elif what == 'nodename':
return nodename
elif what == 'tuple':
return (self.runtime._keys[pos], nodename) | python | def _get(self, key, what):
"""Generic getter magic method.
The node with the nearest but not less hash value is returned.
:param key: the key to look for.
:param what: the information to look for in, allowed values:
- instance (default): associated node instance
- nodename: node name
- pos: index of the given key in the ring
- tuple: ketama compatible (pos, name) tuple
- weight: node weight
"""
if not self.runtime._ring:
return None
pos = self._get_pos(key)
if what == 'pos':
return pos
nodename = self.runtime._ring[self.runtime._keys[pos]]
if what in ['hostname', 'instance', 'port', 'weight']:
return self.runtime._nodes[nodename][what]
elif what == 'dict':
return self.runtime._nodes[nodename]
elif what == 'nodename':
return nodename
elif what == 'tuple':
return (self.runtime._keys[pos], nodename) | [
"def",
"_get",
"(",
"self",
",",
"key",
",",
"what",
")",
":",
"if",
"not",
"self",
".",
"runtime",
".",
"_ring",
":",
"return",
"None",
"pos",
"=",
"self",
".",
"_get_pos",
"(",
"key",
")",
"if",
"what",
"==",
"'pos'",
":",
"return",
"pos",
"nod... | Generic getter magic method.
The node with the nearest but not less hash value is returned.
:param key: the key to look for.
:param what: the information to look for in, allowed values:
- instance (default): associated node instance
- nodename: node name
- pos: index of the given key in the ring
- tuple: ketama compatible (pos, name) tuple
- weight: node weight | [
"Generic",
"getter",
"magic",
"method",
"."
] | 2297471a392e28ed913b3276c2f48d0c01523375 | https://github.com/ultrabug/uhashring/blob/2297471a392e28ed913b3276c2f48d0c01523375/uhashring/ring.py#L140-L168 | train |
ultrabug/uhashring | uhashring/ring.py | HashRing.get_instances | def get_instances(self):
"""Returns a list of the instances of all the configured nodes.
"""
return [c.get('instance') for c in self.runtime._nodes.values()
if c.get('instance')] | python | def get_instances(self):
"""Returns a list of the instances of all the configured nodes.
"""
return [c.get('instance') for c in self.runtime._nodes.values()
if c.get('instance')] | [
"def",
"get_instances",
"(",
"self",
")",
":",
"return",
"[",
"c",
".",
"get",
"(",
"'instance'",
")",
"for",
"c",
"in",
"self",
".",
"runtime",
".",
"_nodes",
".",
"values",
"(",
")",
"if",
"c",
".",
"get",
"(",
"'instance'",
")",
"]"
] | Returns a list of the instances of all the configured nodes. | [
"Returns",
"a",
"list",
"of",
"the",
"instances",
"of",
"all",
"the",
"configured",
"nodes",
"."
] | 2297471a392e28ed913b3276c2f48d0c01523375 | https://github.com/ultrabug/uhashring/blob/2297471a392e28ed913b3276c2f48d0c01523375/uhashring/ring.py#L177-L181 | train |
ultrabug/uhashring | uhashring/ring.py | HashRing.iterate_nodes | def iterate_nodes(self, key, distinct=True):
"""hash_ring compatibility implementation.
Given a string key it returns the nodes as a generator that
can hold the key.
The generator iterates one time through the ring
starting at the correct position.
if `distinct` is set, then the nodes returned will be unique,
i.e. no virtual copies will be returned.
"""
if not self.runtime._ring:
yield None
else:
for node in self.range(key, unique=distinct):
yield node['nodename'] | python | def iterate_nodes(self, key, distinct=True):
"""hash_ring compatibility implementation.
Given a string key it returns the nodes as a generator that
can hold the key.
The generator iterates one time through the ring
starting at the correct position.
if `distinct` is set, then the nodes returned will be unique,
i.e. no virtual copies will be returned.
"""
if not self.runtime._ring:
yield None
else:
for node in self.range(key, unique=distinct):
yield node['nodename'] | [
"def",
"iterate_nodes",
"(",
"self",
",",
"key",
",",
"distinct",
"=",
"True",
")",
":",
"if",
"not",
"self",
".",
"runtime",
".",
"_ring",
":",
"yield",
"None",
"else",
":",
"for",
"node",
"in",
"self",
".",
"range",
"(",
"key",
",",
"unique",
"="... | hash_ring compatibility implementation.
Given a string key it returns the nodes as a generator that
can hold the key.
The generator iterates one time through the ring
starting at the correct position.
if `distinct` is set, then the nodes returned will be unique,
i.e. no virtual copies will be returned. | [
"hash_ring",
"compatibility",
"implementation",
"."
] | 2297471a392e28ed913b3276c2f48d0c01523375 | https://github.com/ultrabug/uhashring/blob/2297471a392e28ed913b3276c2f48d0c01523375/uhashring/ring.py#L244-L258 | train |
ultrabug/uhashring | uhashring/ring.py | HashRing.print_continuum | def print_continuum(self):
"""Prints a ketama compatible continuum report.
"""
numpoints = len(self.runtime._keys)
if numpoints:
print('Numpoints in continuum: {}'.format(numpoints))
else:
print('Continuum empty')
for p in self.get_points():
point, node = p
print('{} ({})'.format(node, point)) | python | def print_continuum(self):
"""Prints a ketama compatible continuum report.
"""
numpoints = len(self.runtime._keys)
if numpoints:
print('Numpoints in continuum: {}'.format(numpoints))
else:
print('Continuum empty')
for p in self.get_points():
point, node = p
print('{} ({})'.format(node, point)) | [
"def",
"print_continuum",
"(",
"self",
")",
":",
"numpoints",
"=",
"len",
"(",
"self",
".",
"runtime",
".",
"_keys",
")",
"if",
"numpoints",
":",
"print",
"(",
"'Numpoints in continuum: {}'",
".",
"format",
"(",
"numpoints",
")",
")",
"else",
":",
"print",... | Prints a ketama compatible continuum report. | [
"Prints",
"a",
"ketama",
"compatible",
"continuum",
"report",
"."
] | 2297471a392e28ed913b3276c2f48d0c01523375 | https://github.com/ultrabug/uhashring/blob/2297471a392e28ed913b3276c2f48d0c01523375/uhashring/ring.py#L260-L270 | train |
ultrabug/uhashring | uhashring/monkey.py | patch_memcache | def patch_memcache():
"""Monkey patch python-memcached to implement our consistent hashring
in its node selection and operations.
"""
def _init(self, servers, *k, **kw):
self._old_init(servers, *k, **kw)
nodes = {}
for server in self.servers:
conf = {
'hostname': server.ip,
'instance': server,
'port': server.port,
'weight': server.weight
}
nodes[server.ip] = conf
self.uhashring = HashRing(nodes)
def _get_server(self, key):
if isinstance(key, tuple):
return self._old_get_server(key)
for i in range(self._SERVER_RETRIES):
for node in self.uhashring.range(key):
if node['instance'].connect():
return node['instance'], key
return None, None
memcache = __import__('memcache')
memcache.Client._old_get_server = memcache.Client._get_server
memcache.Client._old_init = memcache.Client.__init__
memcache.Client.__init__ = _init
memcache.Client._get_server = _get_server | python | def patch_memcache():
"""Monkey patch python-memcached to implement our consistent hashring
in its node selection and operations.
"""
def _init(self, servers, *k, **kw):
self._old_init(servers, *k, **kw)
nodes = {}
for server in self.servers:
conf = {
'hostname': server.ip,
'instance': server,
'port': server.port,
'weight': server.weight
}
nodes[server.ip] = conf
self.uhashring = HashRing(nodes)
def _get_server(self, key):
if isinstance(key, tuple):
return self._old_get_server(key)
for i in range(self._SERVER_RETRIES):
for node in self.uhashring.range(key):
if node['instance'].connect():
return node['instance'], key
return None, None
memcache = __import__('memcache')
memcache.Client._old_get_server = memcache.Client._get_server
memcache.Client._old_init = memcache.Client.__init__
memcache.Client.__init__ = _init
memcache.Client._get_server = _get_server | [
"def",
"patch_memcache",
"(",
")",
":",
"def",
"_init",
"(",
"self",
",",
"servers",
",",
"*",
"k",
",",
"**",
"kw",
")",
":",
"self",
".",
"_old_init",
"(",
"servers",
",",
"*",
"k",
",",
"**",
"kw",
")",
"nodes",
"=",
"{",
"}",
"for",
"server... | Monkey patch python-memcached to implement our consistent hashring
in its node selection and operations. | [
"Monkey",
"patch",
"python",
"-",
"memcached",
"to",
"implement",
"our",
"consistent",
"hashring",
"in",
"its",
"node",
"selection",
"and",
"operations",
"."
] | 2297471a392e28ed913b3276c2f48d0c01523375 | https://github.com/ultrabug/uhashring/blob/2297471a392e28ed913b3276c2f48d0c01523375/uhashring/monkey.py#L8-L42 | train |
ultrabug/uhashring | uhashring/ring_ketama.py | KetamaRing.hashi | def hashi(self, key, replica=0):
"""Returns a ketama compatible hash from the given key.
"""
dh = self._listbytes(md5(str(key).encode('utf-8')).digest())
rd = replica * 4
return (
(dh[3 + rd] << 24) | (dh[2 + rd] << 16) |
(dh[1 + rd] << 8) | dh[0 + rd]) | python | def hashi(self, key, replica=0):
"""Returns a ketama compatible hash from the given key.
"""
dh = self._listbytes(md5(str(key).encode('utf-8')).digest())
rd = replica * 4
return (
(dh[3 + rd] << 24) | (dh[2 + rd] << 16) |
(dh[1 + rd] << 8) | dh[0 + rd]) | [
"def",
"hashi",
"(",
"self",
",",
"key",
",",
"replica",
"=",
"0",
")",
":",
"dh",
"=",
"self",
".",
"_listbytes",
"(",
"md5",
"(",
"str",
"(",
"key",
")",
".",
"encode",
"(",
"'utf-8'",
")",
")",
".",
"digest",
"(",
")",
")",
"rd",
"=",
"rep... | Returns a ketama compatible hash from the given key. | [
"Returns",
"a",
"ketama",
"compatible",
"hash",
"from",
"the",
"given",
"key",
"."
] | 2297471a392e28ed913b3276c2f48d0c01523375 | https://github.com/ultrabug/uhashring/blob/2297471a392e28ed913b3276c2f48d0c01523375/uhashring/ring_ketama.py#L24-L31 | train |
ultrabug/uhashring | uhashring/ring_ketama.py | KetamaRing._hashi_weight_generator | def _hashi_weight_generator(self, node_name, node_conf):
"""Calculate the weight factor of the given node and
yield its hash key for every configured replica.
:param node_name: the node name.
"""
ks = (node_conf['vnodes'] * len(self._nodes) *
node_conf['weight']) // self._weight_sum
for w in range(0, ks):
w_node_name = '%s-%s' % (node_name, w)
for i in range(0, self._replicas):
yield self.hashi(w_node_name, replica=i) | python | def _hashi_weight_generator(self, node_name, node_conf):
"""Calculate the weight factor of the given node and
yield its hash key for every configured replica.
:param node_name: the node name.
"""
ks = (node_conf['vnodes'] * len(self._nodes) *
node_conf['weight']) // self._weight_sum
for w in range(0, ks):
w_node_name = '%s-%s' % (node_name, w)
for i in range(0, self._replicas):
yield self.hashi(w_node_name, replica=i) | [
"def",
"_hashi_weight_generator",
"(",
"self",
",",
"node_name",
",",
"node_conf",
")",
":",
"ks",
"=",
"(",
"node_conf",
"[",
"'vnodes'",
"]",
"*",
"len",
"(",
"self",
".",
"_nodes",
")",
"*",
"node_conf",
"[",
"'weight'",
"]",
")",
"//",
"self",
".",... | Calculate the weight factor of the given node and
yield its hash key for every configured replica.
:param node_name: the node name. | [
"Calculate",
"the",
"weight",
"factor",
"of",
"the",
"given",
"node",
"and",
"yield",
"its",
"hash",
"key",
"for",
"every",
"configured",
"replica",
"."
] | 2297471a392e28ed913b3276c2f48d0c01523375 | https://github.com/ultrabug/uhashring/blob/2297471a392e28ed913b3276c2f48d0c01523375/uhashring/ring_ketama.py#L33-L44 | train |
gatagat/lap | lap/lapmod.py | lapmod | def lapmod(n, cc, ii, kk, fast=True, return_cost=True,
fp_version=FP_DYNAMIC):
"""Solve sparse linear assignment problem using Jonker-Volgenant algorithm.
n: number of rows of the assignment cost matrix
cc: 1D array of all finite elements of the assignement cost matrix
ii: 1D array of indices of the row starts in cc. The following must hold:
ii[0] = 0 and ii[n+1] = len(cc).
kk: 1D array of the column indices so that:
cost[i, kk[ii[i] + k]] == cc[ii[i] + k].
Indices within one row must be sorted.
extend_cost: whether or not extend a non-square matrix [default: False]
cost_limit: an upper limit for a cost of a single assignment
[default: np.inf]
return_cost: whether or not to return the assignment cost
Returns (opt, x, y) where:
opt: cost of the assignment
x: vector of columns assigned to rows
y: vector of rows assigned to columns
or (x, y) if return_cost is not True.
When extend_cost and/or cost_limit is set, all unmatched entries will be
marked by -1 in x/y.
"""
# log = logging.getLogger('lapmod')
check_cost(n, cc, ii, kk)
if fast is True:
# log.debug('[----CR & RT & ARR & augmentation ----]')
x, y = _lapmod(n, cc, ii, kk, fp_version=fp_version)
else:
cc = np.ascontiguousarray(cc, dtype=np.float64)
ii = np.ascontiguousarray(ii, dtype=np.int32)
kk = np.ascontiguousarray(kk, dtype=np.int32)
x = np.empty((n,), dtype=np.int32)
y = np.empty((n,), dtype=np.int32)
v = np.empty((n,), dtype=np.float64)
free_rows = np.empty((n,), dtype=np.int32)
# log.debug('[----Column reduction & reduction transfer----]')
n_free_rows = _pycrrt(n, cc, ii, kk, free_rows, x, y, v)
# log.debug(
# 'free, x, y, v: %s %s %s %s', free_rows[:n_free_rows], x, y, v)
if n_free_rows == 0:
# log.info('Reduction solved it.')
if return_cost is True:
return get_cost(n, cc, ii, kk, x), x, y
else:
return x, y
for it in range(2):
# log.debug('[---Augmenting row reduction (iteration: %d)---]', it)
n_free_rows = _pyarr(
n, cc, ii, kk, n_free_rows, free_rows, x, y, v)
# log.debug(
# 'free, x, y, v: %s %s %s %s', free_rows[:n_free_rows], x, y, v)
if n_free_rows == 0:
# log.info('Augmenting row reduction solved it.')
if return_cost is True:
return get_cost(n, cc, ii, kk, x), x, y
else:
return x, y
# log.info('[----Augmentation----]')
_pya(n, cc, ii, kk, n_free_rows, free_rows, x, y, v)
# log.debug('x, y, v: %s %s %s', x, y, v)
if return_cost is True:
return get_cost(n, cc, ii, kk, x), x, y
else:
return x, y | python | def lapmod(n, cc, ii, kk, fast=True, return_cost=True,
fp_version=FP_DYNAMIC):
"""Solve sparse linear assignment problem using Jonker-Volgenant algorithm.
n: number of rows of the assignment cost matrix
cc: 1D array of all finite elements of the assignement cost matrix
ii: 1D array of indices of the row starts in cc. The following must hold:
ii[0] = 0 and ii[n+1] = len(cc).
kk: 1D array of the column indices so that:
cost[i, kk[ii[i] + k]] == cc[ii[i] + k].
Indices within one row must be sorted.
extend_cost: whether or not extend a non-square matrix [default: False]
cost_limit: an upper limit for a cost of a single assignment
[default: np.inf]
return_cost: whether or not to return the assignment cost
Returns (opt, x, y) where:
opt: cost of the assignment
x: vector of columns assigned to rows
y: vector of rows assigned to columns
or (x, y) if return_cost is not True.
When extend_cost and/or cost_limit is set, all unmatched entries will be
marked by -1 in x/y.
"""
# log = logging.getLogger('lapmod')
check_cost(n, cc, ii, kk)
if fast is True:
# log.debug('[----CR & RT & ARR & augmentation ----]')
x, y = _lapmod(n, cc, ii, kk, fp_version=fp_version)
else:
cc = np.ascontiguousarray(cc, dtype=np.float64)
ii = np.ascontiguousarray(ii, dtype=np.int32)
kk = np.ascontiguousarray(kk, dtype=np.int32)
x = np.empty((n,), dtype=np.int32)
y = np.empty((n,), dtype=np.int32)
v = np.empty((n,), dtype=np.float64)
free_rows = np.empty((n,), dtype=np.int32)
# log.debug('[----Column reduction & reduction transfer----]')
n_free_rows = _pycrrt(n, cc, ii, kk, free_rows, x, y, v)
# log.debug(
# 'free, x, y, v: %s %s %s %s', free_rows[:n_free_rows], x, y, v)
if n_free_rows == 0:
# log.info('Reduction solved it.')
if return_cost is True:
return get_cost(n, cc, ii, kk, x), x, y
else:
return x, y
for it in range(2):
# log.debug('[---Augmenting row reduction (iteration: %d)---]', it)
n_free_rows = _pyarr(
n, cc, ii, kk, n_free_rows, free_rows, x, y, v)
# log.debug(
# 'free, x, y, v: %s %s %s %s', free_rows[:n_free_rows], x, y, v)
if n_free_rows == 0:
# log.info('Augmenting row reduction solved it.')
if return_cost is True:
return get_cost(n, cc, ii, kk, x), x, y
else:
return x, y
# log.info('[----Augmentation----]')
_pya(n, cc, ii, kk, n_free_rows, free_rows, x, y, v)
# log.debug('x, y, v: %s %s %s', x, y, v)
if return_cost is True:
return get_cost(n, cc, ii, kk, x), x, y
else:
return x, y | [
"def",
"lapmod",
"(",
"n",
",",
"cc",
",",
"ii",
",",
"kk",
",",
"fast",
"=",
"True",
",",
"return_cost",
"=",
"True",
",",
"fp_version",
"=",
"FP_DYNAMIC",
")",
":",
"check_cost",
"(",
"n",
",",
"cc",
",",
"ii",
",",
"kk",
")",
"if",
"fast",
"... | Solve sparse linear assignment problem using Jonker-Volgenant algorithm.
n: number of rows of the assignment cost matrix
cc: 1D array of all finite elements of the assignement cost matrix
ii: 1D array of indices of the row starts in cc. The following must hold:
ii[0] = 0 and ii[n+1] = len(cc).
kk: 1D array of the column indices so that:
cost[i, kk[ii[i] + k]] == cc[ii[i] + k].
Indices within one row must be sorted.
extend_cost: whether or not extend a non-square matrix [default: False]
cost_limit: an upper limit for a cost of a single assignment
[default: np.inf]
return_cost: whether or not to return the assignment cost
Returns (opt, x, y) where:
opt: cost of the assignment
x: vector of columns assigned to rows
y: vector of rows assigned to columns
or (x, y) if return_cost is not True.
When extend_cost and/or cost_limit is set, all unmatched entries will be
marked by -1 in x/y. | [
"Solve",
"sparse",
"linear",
"assignment",
"problem",
"using",
"Jonker",
"-",
"Volgenant",
"algorithm",
"."
] | c2b6309ba246d18205a71228cdaea67210e1a039 | https://github.com/gatagat/lap/blob/c2b6309ba246d18205a71228cdaea67210e1a039/lap/lapmod.py#L273-L341 | train |
simonvh/genomepy | genomepy/provider.py | ProviderBase.register_provider | def register_provider(cls, provider):
"""Register method to keep list of providers."""
def decorator(subclass):
"""Register as decorator function."""
cls._providers[provider] = subclass
subclass.name = provider
return subclass
return decorator | python | def register_provider(cls, provider):
"""Register method to keep list of providers."""
def decorator(subclass):
"""Register as decorator function."""
cls._providers[provider] = subclass
subclass.name = provider
return subclass
return decorator | [
"def",
"register_provider",
"(",
"cls",
",",
"provider",
")",
":",
"def",
"decorator",
"(",
"subclass",
")",
":",
"cls",
".",
"_providers",
"[",
"provider",
"]",
"=",
"subclass",
"subclass",
".",
"name",
"=",
"provider",
"return",
"subclass",
"return",
"de... | Register method to keep list of providers. | [
"Register",
"method",
"to",
"keep",
"list",
"of",
"providers",
"."
] | abace2366511dbe855fe1430b1f7d9ec4cbf6d29 | https://github.com/simonvh/genomepy/blob/abace2366511dbe855fe1430b1f7d9ec4cbf6d29/genomepy/provider.py#L73-L80 | train |
simonvh/genomepy | genomepy/provider.py | ProviderBase.tar_to_bigfile | def tar_to_bigfile(self, fname, outfile):
"""Convert tar of multiple FASTAs to one file."""
fnames = []
tmpdir = mkdtemp()
# Extract files to temporary directory
with tarfile.open(fname) as tar:
tar.extractall(path=tmpdir)
for root, _, files in os.walk(tmpdir):
fnames += [os.path.join(root, fname) for fname in files]
# Concatenate
with open(outfile, "w") as out:
for infile in fnames:
for line in open(infile):
out.write(line)
os.unlink(infile)
# Remove temp dir
shutil.rmtree(tmpdir) | python | def tar_to_bigfile(self, fname, outfile):
"""Convert tar of multiple FASTAs to one file."""
fnames = []
tmpdir = mkdtemp()
# Extract files to temporary directory
with tarfile.open(fname) as tar:
tar.extractall(path=tmpdir)
for root, _, files in os.walk(tmpdir):
fnames += [os.path.join(root, fname) for fname in files]
# Concatenate
with open(outfile, "w") as out:
for infile in fnames:
for line in open(infile):
out.write(line)
os.unlink(infile)
# Remove temp dir
shutil.rmtree(tmpdir) | [
"def",
"tar_to_bigfile",
"(",
"self",
",",
"fname",
",",
"outfile",
")",
":",
"fnames",
"=",
"[",
"]",
"tmpdir",
"=",
"mkdtemp",
"(",
")",
"with",
"tarfile",
".",
"open",
"(",
"fname",
")",
"as",
"tar",
":",
"tar",
".",
"extractall",
"(",
"path",
"... | Convert tar of multiple FASTAs to one file. | [
"Convert",
"tar",
"of",
"multiple",
"FASTAs",
"to",
"one",
"file",
"."
] | abace2366511dbe855fe1430b1f7d9ec4cbf6d29 | https://github.com/simonvh/genomepy/blob/abace2366511dbe855fe1430b1f7d9ec4cbf6d29/genomepy/provider.py#L90-L109 | train |
simonvh/genomepy | genomepy/plugin.py | find_plugins | def find_plugins():
"""Locate and initialize all available plugins.
"""
plugin_dir = os.path.dirname(os.path.realpath(__file__))
plugin_dir = os.path.join(plugin_dir, "plugins")
plugin_files = [x[:-3] for x in os.listdir(plugin_dir) if x.endswith(".py")]
sys.path.insert(0, plugin_dir)
for plugin in plugin_files:
__import__(plugin) | python | def find_plugins():
"""Locate and initialize all available plugins.
"""
plugin_dir = os.path.dirname(os.path.realpath(__file__))
plugin_dir = os.path.join(plugin_dir, "plugins")
plugin_files = [x[:-3] for x in os.listdir(plugin_dir) if x.endswith(".py")]
sys.path.insert(0, plugin_dir)
for plugin in plugin_files:
__import__(plugin) | [
"def",
"find_plugins",
"(",
")",
":",
"plugin_dir",
"=",
"os",
".",
"path",
".",
"dirname",
"(",
"os",
".",
"path",
".",
"realpath",
"(",
"__file__",
")",
")",
"plugin_dir",
"=",
"os",
".",
"path",
".",
"join",
"(",
"plugin_dir",
",",
"\"plugins\"",
... | Locate and initialize all available plugins. | [
"Locate",
"and",
"initialize",
"all",
"available",
"plugins",
"."
] | abace2366511dbe855fe1430b1f7d9ec4cbf6d29 | https://github.com/simonvh/genomepy/blob/abace2366511dbe855fe1430b1f7d9ec4cbf6d29/genomepy/plugin.py#L30-L38 | train |
simonvh/genomepy | genomepy/plugin.py | convert | def convert(name):
"""Convert CamelCase to underscore
Parameters
----------
name : str
Camelcase string
Returns
-------
name : str
Converted name
"""
s1 = re.sub('(.)([A-Z][a-z]+)', r'\1_\2', name)
return re.sub('([a-z0-9])([A-Z])', r'\1_\2', s1).lower() | python | def convert(name):
"""Convert CamelCase to underscore
Parameters
----------
name : str
Camelcase string
Returns
-------
name : str
Converted name
"""
s1 = re.sub('(.)([A-Z][a-z]+)', r'\1_\2', name)
return re.sub('([a-z0-9])([A-Z])', r'\1_\2', s1).lower() | [
"def",
"convert",
"(",
"name",
")",
":",
"s1",
"=",
"re",
".",
"sub",
"(",
"'(.)([A-Z][a-z]+)'",
",",
"r'\\1_\\2'",
",",
"name",
")",
"return",
"re",
".",
"sub",
"(",
"'([a-z0-9])([A-Z])'",
",",
"r'\\1_\\2'",
",",
"s1",
")",
".",
"lower",
"(",
")"
] | Convert CamelCase to underscore
Parameters
----------
name : str
Camelcase string
Returns
-------
name : str
Converted name | [
"Convert",
"CamelCase",
"to",
"underscore"
] | abace2366511dbe855fe1430b1f7d9ec4cbf6d29 | https://github.com/simonvh/genomepy/blob/abace2366511dbe855fe1430b1f7d9ec4cbf6d29/genomepy/plugin.py#L40-L54 | train |
simonvh/genomepy | genomepy/plugin.py | init_plugins | def init_plugins():
"""Return dictionary of available plugins
Returns
-------
plugins : dictionary
key is plugin name, value Plugin object
"""
find_plugins()
d = {}
for c in Plugin.__subclasses__():
ins = c()
if ins.name() in config.get("plugin", []):
ins.activate()
d[ins.name()] = ins
return d | python | def init_plugins():
"""Return dictionary of available plugins
Returns
-------
plugins : dictionary
key is plugin name, value Plugin object
"""
find_plugins()
d = {}
for c in Plugin.__subclasses__():
ins = c()
if ins.name() in config.get("plugin", []):
ins.activate()
d[ins.name()] = ins
return d | [
"def",
"init_plugins",
"(",
")",
":",
"find_plugins",
"(",
")",
"d",
"=",
"{",
"}",
"for",
"c",
"in",
"Plugin",
".",
"__subclasses__",
"(",
")",
":",
"ins",
"=",
"c",
"(",
")",
"if",
"ins",
".",
"name",
"(",
")",
"in",
"config",
".",
"get",
"("... | Return dictionary of available plugins
Returns
-------
plugins : dictionary
key is plugin name, value Plugin object | [
"Return",
"dictionary",
"of",
"available",
"plugins"
] | abace2366511dbe855fe1430b1f7d9ec4cbf6d29 | https://github.com/simonvh/genomepy/blob/abace2366511dbe855fe1430b1f7d9ec4cbf6d29/genomepy/plugin.py#L56-L74 | train |
simonvh/genomepy | genomepy/plugin.py | activate | def activate(name):
"""Activate plugin.
Parameters
----------
name : str
Plugin name.
"""
if name in plugins:
plugins[name].activate()
else:
raise Exception("plugin {} not found".format(name)) | python | def activate(name):
"""Activate plugin.
Parameters
----------
name : str
Plugin name.
"""
if name in plugins:
plugins[name].activate()
else:
raise Exception("plugin {} not found".format(name)) | [
"def",
"activate",
"(",
"name",
")",
":",
"if",
"name",
"in",
"plugins",
":",
"plugins",
"[",
"name",
"]",
".",
"activate",
"(",
")",
"else",
":",
"raise",
"Exception",
"(",
"\"plugin {} not found\"",
".",
"format",
"(",
"name",
")",
")"
] | Activate plugin.
Parameters
----------
name : str
Plugin name. | [
"Activate",
"plugin",
"."
] | abace2366511dbe855fe1430b1f7d9ec4cbf6d29 | https://github.com/simonvh/genomepy/blob/abace2366511dbe855fe1430b1f7d9ec4cbf6d29/genomepy/plugin.py#L76-L87 | train |
simonvh/genomepy | genomepy/plugin.py | deactivate | def deactivate(name):
"""Deactivate plugin.
Parameters
----------
name : str
Plugin name.
"""
if name in plugins:
plugins[name].deactivate()
else:
raise Exception("plugin {} not found".format(name)) | python | def deactivate(name):
"""Deactivate plugin.
Parameters
----------
name : str
Plugin name.
"""
if name in plugins:
plugins[name].deactivate()
else:
raise Exception("plugin {} not found".format(name)) | [
"def",
"deactivate",
"(",
"name",
")",
":",
"if",
"name",
"in",
"plugins",
":",
"plugins",
"[",
"name",
"]",
".",
"deactivate",
"(",
")",
"else",
":",
"raise",
"Exception",
"(",
"\"plugin {} not found\"",
".",
"format",
"(",
"name",
")",
")"
] | Deactivate plugin.
Parameters
----------
name : str
Plugin name. | [
"Deactivate",
"plugin",
"."
] | abace2366511dbe855fe1430b1f7d9ec4cbf6d29 | https://github.com/simonvh/genomepy/blob/abace2366511dbe855fe1430b1f7d9ec4cbf6d29/genomepy/plugin.py#L89-L100 | train |
simonvh/genomepy | genomepy/functions.py | manage_config | def manage_config(cmd, *args):
"""Manage genomepy config file."""
if cmd == "file":
print(config.config_file)
elif cmd == "show":
with open(config.config_file) as f:
print(f.read())
elif cmd == "generate":
fname = os.path.join(
user_config_dir("genomepy"), "{}.yaml".format("genomepy")
)
if not os.path.exists(user_config_dir("genomepy")):
os.makedirs(user_config_dir("genomepy"))
with open(fname, "w") as fout:
with open(config.config_file) as fin:
fout.write(fin.read())
print("Created config file {}".format(fname)) | python | def manage_config(cmd, *args):
"""Manage genomepy config file."""
if cmd == "file":
print(config.config_file)
elif cmd == "show":
with open(config.config_file) as f:
print(f.read())
elif cmd == "generate":
fname = os.path.join(
user_config_dir("genomepy"), "{}.yaml".format("genomepy")
)
if not os.path.exists(user_config_dir("genomepy")):
os.makedirs(user_config_dir("genomepy"))
with open(fname, "w") as fout:
with open(config.config_file) as fin:
fout.write(fin.read())
print("Created config file {}".format(fname)) | [
"def",
"manage_config",
"(",
"cmd",
",",
"*",
"args",
")",
":",
"if",
"cmd",
"==",
"\"file\"",
":",
"print",
"(",
"config",
".",
"config_file",
")",
"elif",
"cmd",
"==",
"\"show\"",
":",
"with",
"open",
"(",
"config",
".",
"config_file",
")",
"as",
"... | Manage genomepy config file. | [
"Manage",
"genomepy",
"config",
"file",
"."
] | abace2366511dbe855fe1430b1f7d9ec4cbf6d29 | https://github.com/simonvh/genomepy/blob/abace2366511dbe855fe1430b1f7d9ec4cbf6d29/genomepy/functions.py#L26-L44 | train |
simonvh/genomepy | genomepy/functions.py | search | def search(term, provider=None):
"""
Search for a genome.
If provider is specified, search only that specific provider, else
search all providers. Both the name and description are used for the
search. Seacrch term is case-insensitive.
Parameters
----------
term : str
Search term, case-insensitive.
provider : str , optional
Provider name
Yields
------
tuple
genome information (name/identfier and description)
"""
if provider:
providers = [ProviderBase.create(provider)]
else:
# if provider is not specified search all providers
providers = [ProviderBase.create(p) for
p in ProviderBase.list_providers()]
for p in providers:
for row in p.search(term):
yield [x.encode('latin-1') for x in [p.name] + list(row)] | python | def search(term, provider=None):
"""
Search for a genome.
If provider is specified, search only that specific provider, else
search all providers. Both the name and description are used for the
search. Seacrch term is case-insensitive.
Parameters
----------
term : str
Search term, case-insensitive.
provider : str , optional
Provider name
Yields
------
tuple
genome information (name/identfier and description)
"""
if provider:
providers = [ProviderBase.create(provider)]
else:
# if provider is not specified search all providers
providers = [ProviderBase.create(p) for
p in ProviderBase.list_providers()]
for p in providers:
for row in p.search(term):
yield [x.encode('latin-1') for x in [p.name] + list(row)] | [
"def",
"search",
"(",
"term",
",",
"provider",
"=",
"None",
")",
":",
"if",
"provider",
":",
"providers",
"=",
"[",
"ProviderBase",
".",
"create",
"(",
"provider",
")",
"]",
"else",
":",
"providers",
"=",
"[",
"ProviderBase",
".",
"create",
"(",
"p",
... | Search for a genome.
If provider is specified, search only that specific provider, else
search all providers. Both the name and description are used for the
search. Seacrch term is case-insensitive.
Parameters
----------
term : str
Search term, case-insensitive.
provider : str , optional
Provider name
Yields
------
tuple
genome information (name/identfier and description) | [
"Search",
"for",
"a",
"genome",
"."
] | abace2366511dbe855fe1430b1f7d9ec4cbf6d29 | https://github.com/simonvh/genomepy/blob/abace2366511dbe855fe1430b1f7d9ec4cbf6d29/genomepy/functions.py#L117-L147 | train |
simonvh/genomepy | genomepy/functions.py | install_genome | def install_genome(name, provider, version=None, genome_dir=None, localname=None, mask="soft", regex=None, invert_match=False, annotation=False):
"""
Install a genome.
Parameters
----------
name : str
Genome name
provider : str
Provider name
version : str
Version (only for Ensembl)
genome_dir : str , optional
Where to store the fasta files
localname : str , optional
Custom name for this genome.
mask : str , optional
Default is 'soft', specify 'hard' for hard masking.
regex : str , optional
Regular expression to select specific chromosome / scaffold names.
invert_match : bool , optional
Set to True to select all chromosomes that don't match the regex.
annotation : bool , optional
If set to True, download gene annotation in BED and GTF format.
"""
if not genome_dir:
genome_dir = config.get("genome_dir", None)
if not genome_dir:
raise norns.exceptions.ConfigError("Please provide or configure a genome_dir")
genome_dir = os.path.expanduser(genome_dir)
localname = get_localname(name, localname)
# Download genome from provider
p = ProviderBase.create(provider)
p.download_genome(
name,
genome_dir,
version=version,
mask=mask,
localname=localname,
regex=regex,
invert_match=invert_match)
if annotation:
# Download annotation from provider
p.download_annotation(name, genome_dir, localname=localname, version=version)
g = Genome(localname, genome_dir=genome_dir)
for plugin in get_active_plugins():
plugin.after_genome_download(g)
generate_env() | python | def install_genome(name, provider, version=None, genome_dir=None, localname=None, mask="soft", regex=None, invert_match=False, annotation=False):
"""
Install a genome.
Parameters
----------
name : str
Genome name
provider : str
Provider name
version : str
Version (only for Ensembl)
genome_dir : str , optional
Where to store the fasta files
localname : str , optional
Custom name for this genome.
mask : str , optional
Default is 'soft', specify 'hard' for hard masking.
regex : str , optional
Regular expression to select specific chromosome / scaffold names.
invert_match : bool , optional
Set to True to select all chromosomes that don't match the regex.
annotation : bool , optional
If set to True, download gene annotation in BED and GTF format.
"""
if not genome_dir:
genome_dir = config.get("genome_dir", None)
if not genome_dir:
raise norns.exceptions.ConfigError("Please provide or configure a genome_dir")
genome_dir = os.path.expanduser(genome_dir)
localname = get_localname(name, localname)
# Download genome from provider
p = ProviderBase.create(provider)
p.download_genome(
name,
genome_dir,
version=version,
mask=mask,
localname=localname,
regex=regex,
invert_match=invert_match)
if annotation:
# Download annotation from provider
p.download_annotation(name, genome_dir, localname=localname, version=version)
g = Genome(localname, genome_dir=genome_dir)
for plugin in get_active_plugins():
plugin.after_genome_download(g)
generate_env() | [
"def",
"install_genome",
"(",
"name",
",",
"provider",
",",
"version",
"=",
"None",
",",
"genome_dir",
"=",
"None",
",",
"localname",
"=",
"None",
",",
"mask",
"=",
"\"soft\"",
",",
"regex",
"=",
"None",
",",
"invert_match",
"=",
"False",
",",
"annotatio... | Install a genome.
Parameters
----------
name : str
Genome name
provider : str
Provider name
version : str
Version (only for Ensembl)
genome_dir : str , optional
Where to store the fasta files
localname : str , optional
Custom name for this genome.
mask : str , optional
Default is 'soft', specify 'hard' for hard masking.
regex : str , optional
Regular expression to select specific chromosome / scaffold names.
invert_match : bool , optional
Set to True to select all chromosomes that don't match the regex.
annotation : bool , optional
If set to True, download gene annotation in BED and GTF format. | [
"Install",
"a",
"genome",
"."
] | abace2366511dbe855fe1430b1f7d9ec4cbf6d29 | https://github.com/simonvh/genomepy/blob/abace2366511dbe855fe1430b1f7d9ec4cbf6d29/genomepy/functions.py#L149-L209 | train |
simonvh/genomepy | genomepy/functions.py | generate_exports | def generate_exports():
"""Print export commands for setting environment variables.
"""
env = []
for name in list_installed_genomes():
try:
g = Genome(name)
env_name = re.sub(r'[^\w]+', "_", name).upper()
env.append("export {}={}".format(env_name, g.filename))
except:
pass
return env | python | def generate_exports():
"""Print export commands for setting environment variables.
"""
env = []
for name in list_installed_genomes():
try:
g = Genome(name)
env_name = re.sub(r'[^\w]+', "_", name).upper()
env.append("export {}={}".format(env_name, g.filename))
except:
pass
return env | [
"def",
"generate_exports",
"(",
")",
":",
"env",
"=",
"[",
"]",
"for",
"name",
"in",
"list_installed_genomes",
"(",
")",
":",
"try",
":",
"g",
"=",
"Genome",
"(",
"name",
")",
"env_name",
"=",
"re",
".",
"sub",
"(",
"r'[^\\w]+'",
",",
"\"_\"",
",",
... | Print export commands for setting environment variables. | [
"Print",
"export",
"commands",
"for",
"setting",
"environment",
"variables",
"."
] | abace2366511dbe855fe1430b1f7d9ec4cbf6d29 | https://github.com/simonvh/genomepy/blob/abace2366511dbe855fe1430b1f7d9ec4cbf6d29/genomepy/functions.py#L238-L249 | train |
simonvh/genomepy | genomepy/functions.py | generate_env | def generate_env(fname=None):
"""Generate file with exports.
By default this is in .config/genomepy/exports.txt.
Parameters
----------
fname: strs, optional
Name of the output file.
"""
config_dir = user_config_dir("genomepy")
if os.path.exists(config_dir):
fname = os.path.join(config_dir, "exports.txt")
with open(fname, "w") as fout:
for env in generate_exports():
fout.write("{}\n".format(env)) | python | def generate_env(fname=None):
"""Generate file with exports.
By default this is in .config/genomepy/exports.txt.
Parameters
----------
fname: strs, optional
Name of the output file.
"""
config_dir = user_config_dir("genomepy")
if os.path.exists(config_dir):
fname = os.path.join(config_dir, "exports.txt")
with open(fname, "w") as fout:
for env in generate_exports():
fout.write("{}\n".format(env)) | [
"def",
"generate_env",
"(",
"fname",
"=",
"None",
")",
":",
"config_dir",
"=",
"user_config_dir",
"(",
"\"genomepy\"",
")",
"if",
"os",
".",
"path",
".",
"exists",
"(",
"config_dir",
")",
":",
"fname",
"=",
"os",
".",
"path",
".",
"join",
"(",
"config_... | Generate file with exports.
By default this is in .config/genomepy/exports.txt.
Parameters
----------
fname: strs, optional
Name of the output file. | [
"Generate",
"file",
"with",
"exports",
"."
] | abace2366511dbe855fe1430b1f7d9ec4cbf6d29 | https://github.com/simonvh/genomepy/blob/abace2366511dbe855fe1430b1f7d9ec4cbf6d29/genomepy/functions.py#L251-L266 | train |
simonvh/genomepy | genomepy/functions.py | manage_plugins | def manage_plugins(command, plugin_names=None):
"""Enable or disable plugins.
"""
if plugin_names is None:
plugin_names = []
active_plugins = config.get("plugin", [])
plugins = init_plugins()
if command == "enable":
for name in plugin_names:
if name not in plugins:
raise ValueError("Unknown plugin: {}".format(name))
if name not in active_plugins:
active_plugins.append(name)
elif command == "disable":
for name in plugin_names:
if name in active_plugins:
active_plugins.remove(name)
elif command == "list":
print("{:20}{}".format("plugin", "enabled"))
for plugin in sorted(plugins):
print("{:20}{}".format(plugin, {False:"", True:"*"}[plugin in active_plugins]))
else:
raise ValueError("Invalid plugin command")
config["plugin"] = active_plugins
config.save()
if command in ["enable", "disable"]:
print("Enabled plugins: {}".format(", ".join(sorted(active_plugins)))) | python | def manage_plugins(command, plugin_names=None):
"""Enable or disable plugins.
"""
if plugin_names is None:
plugin_names = []
active_plugins = config.get("plugin", [])
plugins = init_plugins()
if command == "enable":
for name in plugin_names:
if name not in plugins:
raise ValueError("Unknown plugin: {}".format(name))
if name not in active_plugins:
active_plugins.append(name)
elif command == "disable":
for name in plugin_names:
if name in active_plugins:
active_plugins.remove(name)
elif command == "list":
print("{:20}{}".format("plugin", "enabled"))
for plugin in sorted(plugins):
print("{:20}{}".format(plugin, {False:"", True:"*"}[plugin in active_plugins]))
else:
raise ValueError("Invalid plugin command")
config["plugin"] = active_plugins
config.save()
if command in ["enable", "disable"]:
print("Enabled plugins: {}".format(", ".join(sorted(active_plugins)))) | [
"def",
"manage_plugins",
"(",
"command",
",",
"plugin_names",
"=",
"None",
")",
":",
"if",
"plugin_names",
"is",
"None",
":",
"plugin_names",
"=",
"[",
"]",
"active_plugins",
"=",
"config",
".",
"get",
"(",
"\"plugin\"",
",",
"[",
"]",
")",
"plugins",
"=... | Enable or disable plugins. | [
"Enable",
"or",
"disable",
"plugins",
"."
] | abace2366511dbe855fe1430b1f7d9ec4cbf6d29 | https://github.com/simonvh/genomepy/blob/abace2366511dbe855fe1430b1f7d9ec4cbf6d29/genomepy/functions.py#L514-L541 | train |
simonvh/genomepy | genomepy/functions.py | Genome.get_random_sequences | def get_random_sequences(self, n=10, length=200, chroms=None, max_n=0.1):
"""Return random genomic sequences.
Parameters
----------
n : int , optional
Number of sequences to return.
length : int , optional
Length of sequences to return.
chroms : list , optional
Return sequences only from these chromosomes.
max_n : float , optional
Maximum fraction of Ns.
Returns
-------
coords : list
List with [chrom, start, end] genomic coordinates.
"""
retries = 100
cutoff = length * max_n
if not chroms:
chroms = self.keys()
try:
gap_sizes = self.gap_sizes()
except:
gap_sizes = {}
sizes = dict([(chrom, len(self[chrom]) - gap_sizes.get(chrom, 0)) for chrom in chroms])
l = [(sizes[x], x) for x in chroms if
sizes[x] / len(self[x]) > 0.1 and sizes[x] > 10 * length]
chroms = _weighted_selection(l, n)
coords = []
count = {}
for chrom in chroms:
if chrom in count:
count[chrom] += 1
else:
count[chrom] = 1
for chrom in chroms:
for i in range(retries):
start = int(random.random() * (sizes[chrom] - length))
end = start + length
count_n = self[chrom][start:end].seq.upper().count("N")
if count_n <= cutoff:
break
if count_n > cutoff:
raise ValueError("Failed to find suitable non-N sequence for {}".format(chrom))
coords.append([chrom, start, end])
return coords | python | def get_random_sequences(self, n=10, length=200, chroms=None, max_n=0.1):
"""Return random genomic sequences.
Parameters
----------
n : int , optional
Number of sequences to return.
length : int , optional
Length of sequences to return.
chroms : list , optional
Return sequences only from these chromosomes.
max_n : float , optional
Maximum fraction of Ns.
Returns
-------
coords : list
List with [chrom, start, end] genomic coordinates.
"""
retries = 100
cutoff = length * max_n
if not chroms:
chroms = self.keys()
try:
gap_sizes = self.gap_sizes()
except:
gap_sizes = {}
sizes = dict([(chrom, len(self[chrom]) - gap_sizes.get(chrom, 0)) for chrom in chroms])
l = [(sizes[x], x) for x in chroms if
sizes[x] / len(self[x]) > 0.1 and sizes[x] > 10 * length]
chroms = _weighted_selection(l, n)
coords = []
count = {}
for chrom in chroms:
if chrom in count:
count[chrom] += 1
else:
count[chrom] = 1
for chrom in chroms:
for i in range(retries):
start = int(random.random() * (sizes[chrom] - length))
end = start + length
count_n = self[chrom][start:end].seq.upper().count("N")
if count_n <= cutoff:
break
if count_n > cutoff:
raise ValueError("Failed to find suitable non-N sequence for {}".format(chrom))
coords.append([chrom, start, end])
return coords | [
"def",
"get_random_sequences",
"(",
"self",
",",
"n",
"=",
"10",
",",
"length",
"=",
"200",
",",
"chroms",
"=",
"None",
",",
"max_n",
"=",
"0.1",
")",
":",
"retries",
"=",
"100",
"cutoff",
"=",
"length",
"*",
"max_n",
"if",
"not",
"chroms",
":",
"c... | Return random genomic sequences.
Parameters
----------
n : int , optional
Number of sequences to return.
length : int , optional
Length of sequences to return.
chroms : list , optional
Return sequences only from these chromosomes.
max_n : float , optional
Maximum fraction of Ns.
Returns
-------
coords : list
List with [chrom, start, end] genomic coordinates. | [
"Return",
"random",
"genomic",
"sequences",
"."
] | abace2366511dbe855fe1430b1f7d9ec4cbf6d29 | https://github.com/simonvh/genomepy/blob/abace2366511dbe855fe1430b1f7d9ec4cbf6d29/genomepy/functions.py#L455-L512 | train |
simonvh/genomepy | genomepy/cli.py | search | def search(term, provider=None):
"""Search for genomes that contain TERM in their name or description."""
for row in genomepy.search(term, provider):
print("\t".join([x.decode('utf-8', 'ignore') for x in row])) | python | def search(term, provider=None):
"""Search for genomes that contain TERM in their name or description."""
for row in genomepy.search(term, provider):
print("\t".join([x.decode('utf-8', 'ignore') for x in row])) | [
"def",
"search",
"(",
"term",
",",
"provider",
"=",
"None",
")",
":",
"for",
"row",
"in",
"genomepy",
".",
"search",
"(",
"term",
",",
"provider",
")",
":",
"print",
"(",
"\"\\t\"",
".",
"join",
"(",
"[",
"x",
".",
"decode",
"(",
"'utf-8'",
",",
... | Search for genomes that contain TERM in their name or description. | [
"Search",
"for",
"genomes",
"that",
"contain",
"TERM",
"in",
"their",
"name",
"or",
"description",
"."
] | abace2366511dbe855fe1430b1f7d9ec4cbf6d29 | https://github.com/simonvh/genomepy/blob/abace2366511dbe855fe1430b1f7d9ec4cbf6d29/genomepy/cli.py#L20-L23 | train |
simonvh/genomepy | genomepy/cli.py | install | def install(name, provider, genome_dir, localname, mask, regex, match, annotation):
"""Install genome NAME from provider PROVIDER in directory GENOME_DIR."""
genomepy.install_genome(
name, provider, genome_dir=genome_dir, localname=localname, mask=mask,
regex=regex, invert_match=not(match), annotation=annotation) | python | def install(name, provider, genome_dir, localname, mask, regex, match, annotation):
"""Install genome NAME from provider PROVIDER in directory GENOME_DIR."""
genomepy.install_genome(
name, provider, genome_dir=genome_dir, localname=localname, mask=mask,
regex=regex, invert_match=not(match), annotation=annotation) | [
"def",
"install",
"(",
"name",
",",
"provider",
",",
"genome_dir",
",",
"localname",
",",
"mask",
",",
"regex",
",",
"match",
",",
"annotation",
")",
":",
"genomepy",
".",
"install_genome",
"(",
"name",
",",
"provider",
",",
"genome_dir",
"=",
"genome_dir"... | Install genome NAME from provider PROVIDER in directory GENOME_DIR. | [
"Install",
"genome",
"NAME",
"from",
"provider",
"PROVIDER",
"in",
"directory",
"GENOME_DIR",
"."
] | abace2366511dbe855fe1430b1f7d9ec4cbf6d29 | https://github.com/simonvh/genomepy/blob/abace2366511dbe855fe1430b1f7d9ec4cbf6d29/genomepy/cli.py#L34-L38 | train |
simonvh/genomepy | genomepy/utils.py | generate_gap_bed | def generate_gap_bed(fname, outname):
""" Generate a BED file with gap locations.
Parameters
----------
fname : str
Filename of input FASTA file.
outname : str
Filename of output BED file.
"""
f = Fasta(fname)
with open(outname, "w") as bed:
for chrom in f.keys():
for m in re.finditer(r'N+', f[chrom][:].seq):
bed.write("{}\t{}\t{}\n".format(chrom, m.start(0), m.end(0))) | python | def generate_gap_bed(fname, outname):
""" Generate a BED file with gap locations.
Parameters
----------
fname : str
Filename of input FASTA file.
outname : str
Filename of output BED file.
"""
f = Fasta(fname)
with open(outname, "w") as bed:
for chrom in f.keys():
for m in re.finditer(r'N+', f[chrom][:].seq):
bed.write("{}\t{}\t{}\n".format(chrom, m.start(0), m.end(0))) | [
"def",
"generate_gap_bed",
"(",
"fname",
",",
"outname",
")",
":",
"f",
"=",
"Fasta",
"(",
"fname",
")",
"with",
"open",
"(",
"outname",
",",
"\"w\"",
")",
"as",
"bed",
":",
"for",
"chrom",
"in",
"f",
".",
"keys",
"(",
")",
":",
"for",
"m",
"in",... | Generate a BED file with gap locations.
Parameters
----------
fname : str
Filename of input FASTA file.
outname : str
Filename of output BED file. | [
"Generate",
"a",
"BED",
"file",
"with",
"gap",
"locations",
"."
] | abace2366511dbe855fe1430b1f7d9ec4cbf6d29 | https://github.com/simonvh/genomepy/blob/abace2366511dbe855fe1430b1f7d9ec4cbf6d29/genomepy/utils.py#L10-L25 | train |
simonvh/genomepy | genomepy/utils.py | generate_sizes | def generate_sizes(name, genome_dir):
"""Generate a sizes file with length of sequences in FASTA file."""
fa = os.path.join(genome_dir, name, "{}.fa".format(name))
sizes = fa + ".sizes"
g = Fasta(fa)
with open(sizes, "w") as f:
for seqname in g.keys():
f.write("{}\t{}\n".format(seqname, len(g[seqname]))) | python | def generate_sizes(name, genome_dir):
"""Generate a sizes file with length of sequences in FASTA file."""
fa = os.path.join(genome_dir, name, "{}.fa".format(name))
sizes = fa + ".sizes"
g = Fasta(fa)
with open(sizes, "w") as f:
for seqname in g.keys():
f.write("{}\t{}\n".format(seqname, len(g[seqname]))) | [
"def",
"generate_sizes",
"(",
"name",
",",
"genome_dir",
")",
":",
"fa",
"=",
"os",
".",
"path",
".",
"join",
"(",
"genome_dir",
",",
"name",
",",
"\"{}.fa\"",
".",
"format",
"(",
"name",
")",
")",
"sizes",
"=",
"fa",
"+",
"\".sizes\"",
"g",
"=",
"... | Generate a sizes file with length of sequences in FASTA file. | [
"Generate",
"a",
"sizes",
"file",
"with",
"length",
"of",
"sequences",
"in",
"FASTA",
"file",
"."
] | abace2366511dbe855fe1430b1f7d9ec4cbf6d29 | https://github.com/simonvh/genomepy/blob/abace2366511dbe855fe1430b1f7d9ec4cbf6d29/genomepy/utils.py#L27-L34 | train |
simonvh/genomepy | genomepy/utils.py | filter_fasta | def filter_fasta(infa, outfa, regex=".*", v=False, force=False):
"""Filter fasta file based on regex.
Parameters
----------
infa : str
Filename of input fasta file.
outfa : str
Filename of output fasta file. Cannot be the same as infa.
regex : str, optional
Regular expression used for selecting sequences.
v : bool, optional
If set to True, select all sequence *not* matching regex.
force : bool, optional
If set to True, overwrite outfa if it already exists.
Returns
-------
fasta : Fasta instance
pyfaidx Fasta instance of newly created file
"""
if infa == outfa:
raise ValueError("Input and output FASTA are the same file.")
if os.path.exists(outfa):
if force:
os.unlink(outfa)
if os.path.exists(outfa + ".fai"):
os.unlink(outfa + ".fai")
else:
raise ValueError(
"{} already exists, set force to True to overwrite".format(outfa))
filt_function = re.compile(regex).search
fa = Fasta(infa, filt_function=filt_function)
seqs = fa.keys()
if v:
original_fa = Fasta(infa)
seqs = [s for s in original_fa.keys() if s not in seqs]
fa = original_fa
if len(seqs) == 0:
raise ValueError("No sequences left after filtering!")
with open(outfa, "w") as out:
for chrom in seqs:
out.write(">{}\n".format(fa[chrom].name))
out.write("{}\n".format(fa[chrom][:].seq))
return Fasta(outfa) | python | def filter_fasta(infa, outfa, regex=".*", v=False, force=False):
"""Filter fasta file based on regex.
Parameters
----------
infa : str
Filename of input fasta file.
outfa : str
Filename of output fasta file. Cannot be the same as infa.
regex : str, optional
Regular expression used for selecting sequences.
v : bool, optional
If set to True, select all sequence *not* matching regex.
force : bool, optional
If set to True, overwrite outfa if it already exists.
Returns
-------
fasta : Fasta instance
pyfaidx Fasta instance of newly created file
"""
if infa == outfa:
raise ValueError("Input and output FASTA are the same file.")
if os.path.exists(outfa):
if force:
os.unlink(outfa)
if os.path.exists(outfa + ".fai"):
os.unlink(outfa + ".fai")
else:
raise ValueError(
"{} already exists, set force to True to overwrite".format(outfa))
filt_function = re.compile(regex).search
fa = Fasta(infa, filt_function=filt_function)
seqs = fa.keys()
if v:
original_fa = Fasta(infa)
seqs = [s for s in original_fa.keys() if s not in seqs]
fa = original_fa
if len(seqs) == 0:
raise ValueError("No sequences left after filtering!")
with open(outfa, "w") as out:
for chrom in seqs:
out.write(">{}\n".format(fa[chrom].name))
out.write("{}\n".format(fa[chrom][:].seq))
return Fasta(outfa) | [
"def",
"filter_fasta",
"(",
"infa",
",",
"outfa",
",",
"regex",
"=",
"\".*\"",
",",
"v",
"=",
"False",
",",
"force",
"=",
"False",
")",
":",
"if",
"infa",
"==",
"outfa",
":",
"raise",
"ValueError",
"(",
"\"Input and output FASTA are the same file.\"",
")",
... | Filter fasta file based on regex.
Parameters
----------
infa : str
Filename of input fasta file.
outfa : str
Filename of output fasta file. Cannot be the same as infa.
regex : str, optional
Regular expression used for selecting sequences.
v : bool, optional
If set to True, select all sequence *not* matching regex.
force : bool, optional
If set to True, overwrite outfa if it already exists.
Returns
-------
fasta : Fasta instance
pyfaidx Fasta instance of newly created file | [
"Filter",
"fasta",
"file",
"based",
"on",
"regex",
"."
] | abace2366511dbe855fe1430b1f7d9ec4cbf6d29 | https://github.com/simonvh/genomepy/blob/abace2366511dbe855fe1430b1f7d9ec4cbf6d29/genomepy/utils.py#L36-L89 | train |
simonvh/genomepy | genomepy/utils.py | cmd_ok | def cmd_ok(cmd):
"""Returns True if cmd can be run.
"""
try:
sp.check_call(cmd, stderr=sp.PIPE, stdout=sp.PIPE)
except sp.CalledProcessError:
# bwa gives return code of 1 with no argument
pass
except:
sys.stderr.write("{} not found, skipping\n".format(cmd))
return False
return True | python | def cmd_ok(cmd):
"""Returns True if cmd can be run.
"""
try:
sp.check_call(cmd, stderr=sp.PIPE, stdout=sp.PIPE)
except sp.CalledProcessError:
# bwa gives return code of 1 with no argument
pass
except:
sys.stderr.write("{} not found, skipping\n".format(cmd))
return False
return True | [
"def",
"cmd_ok",
"(",
"cmd",
")",
":",
"try",
":",
"sp",
".",
"check_call",
"(",
"cmd",
",",
"stderr",
"=",
"sp",
".",
"PIPE",
",",
"stdout",
"=",
"sp",
".",
"PIPE",
")",
"except",
"sp",
".",
"CalledProcessError",
":",
"pass",
"except",
":",
"sys",... | Returns True if cmd can be run. | [
"Returns",
"True",
"if",
"cmd",
"can",
"be",
"run",
"."
] | abace2366511dbe855fe1430b1f7d9ec4cbf6d29 | https://github.com/simonvh/genomepy/blob/abace2366511dbe855fe1430b1f7d9ec4cbf6d29/genomepy/utils.py#L101-L112 | train |
simonvh/genomepy | genomepy/utils.py | run_index_cmd | def run_index_cmd(name, cmd):
"""Run command, show errors if the returncode is non-zero."""
sys.stderr.write("Creating {} index...\n".format(name))
# Create index
p = sp.Popen(cmd, shell=True, stdout=sp.PIPE, stderr=sp.PIPE)
stdout, stderr = p.communicate()
if p.returncode != 0:
sys.stderr.write("Index for {} failed\n".format(name))
sys.stderr.write(stdout)
sys.stderr.write(stderr) | python | def run_index_cmd(name, cmd):
"""Run command, show errors if the returncode is non-zero."""
sys.stderr.write("Creating {} index...\n".format(name))
# Create index
p = sp.Popen(cmd, shell=True, stdout=sp.PIPE, stderr=sp.PIPE)
stdout, stderr = p.communicate()
if p.returncode != 0:
sys.stderr.write("Index for {} failed\n".format(name))
sys.stderr.write(stdout)
sys.stderr.write(stderr) | [
"def",
"run_index_cmd",
"(",
"name",
",",
"cmd",
")",
":",
"sys",
".",
"stderr",
".",
"write",
"(",
"\"Creating {} index...\\n\"",
".",
"format",
"(",
"name",
")",
")",
"p",
"=",
"sp",
".",
"Popen",
"(",
"cmd",
",",
"shell",
"=",
"True",
",",
"stdout... | Run command, show errors if the returncode is non-zero. | [
"Run",
"command",
"show",
"errors",
"if",
"the",
"returncode",
"is",
"non",
"-",
"zero",
"."
] | abace2366511dbe855fe1430b1f7d9ec4cbf6d29 | https://github.com/simonvh/genomepy/blob/abace2366511dbe855fe1430b1f7d9ec4cbf6d29/genomepy/utils.py#L114-L123 | train |
peo3/cgroup-utils | cgutils/cgroup.py | scan_cgroups | def scan_cgroups(subsys_name, filters=list()):
"""
It returns a control group hierarchy which belong to the subsys_name.
When collecting cgroups, filters are applied to the cgroups. See pydoc
of apply_filters method of CGroup for more information about the filters.
"""
status = SubsystemStatus()
if subsys_name not in status.get_all():
raise NoSuchSubsystemError("No such subsystem found: " + subsys_name)
if subsys_name not in status.get_available():
raise EnvironmentError("Disabled in the kernel: " + subsys_name)
if subsys_name not in status.get_enabled():
raise EnvironmentError("Not enabled in the system: " + subsys_name)
subsystem = _get_subsystem(subsys_name)
mount_point = status.get_path(subsys_name)
return _scan_cgroups_recursive(subsystem, mount_point, mount_point, filters) | python | def scan_cgroups(subsys_name, filters=list()):
"""
It returns a control group hierarchy which belong to the subsys_name.
When collecting cgroups, filters are applied to the cgroups. See pydoc
of apply_filters method of CGroup for more information about the filters.
"""
status = SubsystemStatus()
if subsys_name not in status.get_all():
raise NoSuchSubsystemError("No such subsystem found: " + subsys_name)
if subsys_name not in status.get_available():
raise EnvironmentError("Disabled in the kernel: " + subsys_name)
if subsys_name not in status.get_enabled():
raise EnvironmentError("Not enabled in the system: " + subsys_name)
subsystem = _get_subsystem(subsys_name)
mount_point = status.get_path(subsys_name)
return _scan_cgroups_recursive(subsystem, mount_point, mount_point, filters) | [
"def",
"scan_cgroups",
"(",
"subsys_name",
",",
"filters",
"=",
"list",
"(",
")",
")",
":",
"status",
"=",
"SubsystemStatus",
"(",
")",
"if",
"subsys_name",
"not",
"in",
"status",
".",
"get_all",
"(",
")",
":",
"raise",
"NoSuchSubsystemError",
"(",
"\"No s... | It returns a control group hierarchy which belong to the subsys_name.
When collecting cgroups, filters are applied to the cgroups. See pydoc
of apply_filters method of CGroup for more information about the filters. | [
"It",
"returns",
"a",
"control",
"group",
"hierarchy",
"which",
"belong",
"to",
"the",
"subsys_name",
".",
"When",
"collecting",
"cgroups",
"filters",
"are",
"applied",
"to",
"the",
"cgroups",
".",
"See",
"pydoc",
"of",
"apply_filters",
"method",
"of",
"CGroup... | fd7e99f438ce334bac5669fba0d08a6502fd7a82 | https://github.com/peo3/cgroup-utils/blob/fd7e99f438ce334bac5669fba0d08a6502fd7a82/cgutils/cgroup.py#L917-L935 | train |
peo3/cgroup-utils | cgutils/cgroup.py | walk_cgroups | def walk_cgroups(cgroup, action, opaque):
"""
The function applies the action function with the opaque object
to each control group under the cgroup recursively.
"""
action(cgroup, opaque)
for child in cgroup.childs:
walk_cgroups(child, action, opaque) | python | def walk_cgroups(cgroup, action, opaque):
"""
The function applies the action function with the opaque object
to each control group under the cgroup recursively.
"""
action(cgroup, opaque)
for child in cgroup.childs:
walk_cgroups(child, action, opaque) | [
"def",
"walk_cgroups",
"(",
"cgroup",
",",
"action",
",",
"opaque",
")",
":",
"action",
"(",
"cgroup",
",",
"opaque",
")",
"for",
"child",
"in",
"cgroup",
".",
"childs",
":",
"walk_cgroups",
"(",
"child",
",",
"action",
",",
"opaque",
")"
] | The function applies the action function with the opaque object
to each control group under the cgroup recursively. | [
"The",
"function",
"applies",
"the",
"action",
"function",
"with",
"the",
"opaque",
"object",
"to",
"each",
"control",
"group",
"under",
"the",
"cgroup",
"recursively",
"."
] | fd7e99f438ce334bac5669fba0d08a6502fd7a82 | https://github.com/peo3/cgroup-utils/blob/fd7e99f438ce334bac5669fba0d08a6502fd7a82/cgutils/cgroup.py#L938-L945 | train |
peo3/cgroup-utils | cgutils/cgroup.py | get_cgroup | def get_cgroup(fullpath):
"""
It returns a CGroup object which is pointed by the fullpath.
"""
# Canonicalize symbolic links
fullpath = os.path.realpath(fullpath)
status = SubsystemStatus()
name = None
for name, path in status.paths.items():
if path in fullpath:
break
else:
raise Exception('Invalid path: ' + fullpath)
subsys = _get_subsystem(name)
return CGroup(subsys, fullpath) | python | def get_cgroup(fullpath):
"""
It returns a CGroup object which is pointed by the fullpath.
"""
# Canonicalize symbolic links
fullpath = os.path.realpath(fullpath)
status = SubsystemStatus()
name = None
for name, path in status.paths.items():
if path in fullpath:
break
else:
raise Exception('Invalid path: ' + fullpath)
subsys = _get_subsystem(name)
return CGroup(subsys, fullpath) | [
"def",
"get_cgroup",
"(",
"fullpath",
")",
":",
"fullpath",
"=",
"os",
".",
"path",
".",
"realpath",
"(",
"fullpath",
")",
"status",
"=",
"SubsystemStatus",
"(",
")",
"name",
"=",
"None",
"for",
"name",
",",
"path",
"in",
"status",
".",
"paths",
".",
... | It returns a CGroup object which is pointed by the fullpath. | [
"It",
"returns",
"a",
"CGroup",
"object",
"which",
"is",
"pointed",
"by",
"the",
"fullpath",
"."
] | fd7e99f438ce334bac5669fba0d08a6502fd7a82 | https://github.com/peo3/cgroup-utils/blob/fd7e99f438ce334bac5669fba0d08a6502fd7a82/cgutils/cgroup.py#L948-L964 | train |
peo3/cgroup-utils | cgutils/cgroup.py | RdmaStat.parse | def parse(content):
""" Parse rdma.curren and rdma.max
Example contents:
mlx4_0 hca_handle=2 hca_object=2000
ocrdma1 hca_handle=3 hca_object=max
>>> RdmaStat.parse("mlx4_0 hca_handle=2 hca_object=2000\\nocrdma1 hca_handle=3 hca_object=max")
{'mlx4_0': {'hca_handle': 2, 'hca_object': 2000}, 'ocrdma1': {'hca_handle': 3, 'hca_object': 'max'}}
"""
ret = {}
lines = content.split('\n')
for line in lines:
m = RdmaStat._RE.match(line)
if m is None:
continue
name = m.group('name')
hca_handle = long(m.group('hca_handle'))
hca_object = m.group('hca_object')
if hca_object != "max":
hca_object = long(hca_object)
ret[name] = {"hca_handle": hca_handle, "hca_object": hca_object}
return ret | python | def parse(content):
""" Parse rdma.curren and rdma.max
Example contents:
mlx4_0 hca_handle=2 hca_object=2000
ocrdma1 hca_handle=3 hca_object=max
>>> RdmaStat.parse("mlx4_0 hca_handle=2 hca_object=2000\\nocrdma1 hca_handle=3 hca_object=max")
{'mlx4_0': {'hca_handle': 2, 'hca_object': 2000}, 'ocrdma1': {'hca_handle': 3, 'hca_object': 'max'}}
"""
ret = {}
lines = content.split('\n')
for line in lines:
m = RdmaStat._RE.match(line)
if m is None:
continue
name = m.group('name')
hca_handle = long(m.group('hca_handle'))
hca_object = m.group('hca_object')
if hca_object != "max":
hca_object = long(hca_object)
ret[name] = {"hca_handle": hca_handle, "hca_object": hca_object}
return ret | [
"def",
"parse",
"(",
"content",
")",
":",
"ret",
"=",
"{",
"}",
"lines",
"=",
"content",
".",
"split",
"(",
"'\\n'",
")",
"for",
"line",
"in",
"lines",
":",
"m",
"=",
"RdmaStat",
".",
"_RE",
".",
"match",
"(",
"line",
")",
"if",
"m",
"is",
"Non... | Parse rdma.curren and rdma.max
Example contents:
mlx4_0 hca_handle=2 hca_object=2000
ocrdma1 hca_handle=3 hca_object=max
>>> RdmaStat.parse("mlx4_0 hca_handle=2 hca_object=2000\\nocrdma1 hca_handle=3 hca_object=max")
{'mlx4_0': {'hca_handle': 2, 'hca_object': 2000}, 'ocrdma1': {'hca_handle': 3, 'hca_object': 'max'}} | [
"Parse",
"rdma",
".",
"curren",
"and",
"rdma",
".",
"max"
] | fd7e99f438ce334bac5669fba0d08a6502fd7a82 | https://github.com/peo3/cgroup-utils/blob/fd7e99f438ce334bac5669fba0d08a6502fd7a82/cgutils/cgroup.py#L313-L335 | train |
peo3/cgroup-utils | cgutils/cgroup.py | CGroup.apply_filters | def apply_filters(self, filters):
"""
It applies a specified filters. The filters are used to reduce the control groups
which are accessed by get_confgs, get_stats, and get_defaults methods.
"""
_configs = self.configs
_stats = self.stats
self.configs = {}
self.stats = {}
for f in filters:
if f in _configs:
self.configs[f] = _configs[f]
elif f in _stats:
self.stats[f] = _stats[f]
else:
raise NoSuchControlFileError("%s for %s" % (f, self.subsystem.name)) | python | def apply_filters(self, filters):
"""
It applies a specified filters. The filters are used to reduce the control groups
which are accessed by get_confgs, get_stats, and get_defaults methods.
"""
_configs = self.configs
_stats = self.stats
self.configs = {}
self.stats = {}
for f in filters:
if f in _configs:
self.configs[f] = _configs[f]
elif f in _stats:
self.stats[f] = _stats[f]
else:
raise NoSuchControlFileError("%s for %s" % (f, self.subsystem.name)) | [
"def",
"apply_filters",
"(",
"self",
",",
"filters",
")",
":",
"_configs",
"=",
"self",
".",
"configs",
"_stats",
"=",
"self",
".",
"stats",
"self",
".",
"configs",
"=",
"{",
"}",
"self",
".",
"stats",
"=",
"{",
"}",
"for",
"f",
"in",
"filters",
":... | It applies a specified filters. The filters are used to reduce the control groups
which are accessed by get_confgs, get_stats, and get_defaults methods. | [
"It",
"applies",
"a",
"specified",
"filters",
".",
"The",
"filters",
"are",
"used",
"to",
"reduce",
"the",
"control",
"groups",
"which",
"are",
"accessed",
"by",
"get_confgs",
"get_stats",
"and",
"get_defaults",
"methods",
"."
] | fd7e99f438ce334bac5669fba0d08a6502fd7a82 | https://github.com/peo3/cgroup-utils/blob/fd7e99f438ce334bac5669fba0d08a6502fd7a82/cgutils/cgroup.py#L722-L737 | train |
peo3/cgroup-utils | cgutils/cgroup.py | CGroup.get_configs | def get_configs(self):
"""
It returns a name and a current value pairs of control files
which are categorised in the configs group.
"""
configs = {}
for name, default in self.configs.items():
cls = default.__class__
path = self.paths[name]
if os.path.exists(path):
try:
configs[name] = self._PARSERS[cls](fileops.read(path))
except IOError as e:
if e.errno == errno.EOPNOTSUPP:
# Since 3.5 memory.memsw.* are always created even if disabled.
# If disabled we will get EOPNOTSUPP when read or write them.
# See commit af36f906c0f4c2ffa0482ecdf856a33dc88ae8c5 of the kernel.
pass
else:
raise
return configs | python | def get_configs(self):
"""
It returns a name and a current value pairs of control files
which are categorised in the configs group.
"""
configs = {}
for name, default in self.configs.items():
cls = default.__class__
path = self.paths[name]
if os.path.exists(path):
try:
configs[name] = self._PARSERS[cls](fileops.read(path))
except IOError as e:
if e.errno == errno.EOPNOTSUPP:
# Since 3.5 memory.memsw.* are always created even if disabled.
# If disabled we will get EOPNOTSUPP when read or write them.
# See commit af36f906c0f4c2ffa0482ecdf856a33dc88ae8c5 of the kernel.
pass
else:
raise
return configs | [
"def",
"get_configs",
"(",
"self",
")",
":",
"configs",
"=",
"{",
"}",
"for",
"name",
",",
"default",
"in",
"self",
".",
"configs",
".",
"items",
"(",
")",
":",
"cls",
"=",
"default",
".",
"__class__",
"path",
"=",
"self",
".",
"paths",
"[",
"name"... | It returns a name and a current value pairs of control files
which are categorised in the configs group. | [
"It",
"returns",
"a",
"name",
"and",
"a",
"current",
"value",
"pairs",
"of",
"control",
"files",
"which",
"are",
"categorised",
"in",
"the",
"configs",
"group",
"."
] | fd7e99f438ce334bac5669fba0d08a6502fd7a82 | https://github.com/peo3/cgroup-utils/blob/fd7e99f438ce334bac5669fba0d08a6502fd7a82/cgutils/cgroup.py#L739-L759 | train |
peo3/cgroup-utils | cgutils/cgroup.py | CGroup.get_stats | def get_stats(self):
"""
It returns a name and a value pairs of control files
which are categorised in the stats group.
"""
stats = {}
for name, cls in self.stats.items():
path = self.paths[name]
if os.path.exists(path):
try:
stats[name] = self._PARSERS[cls](fileops.read(path))
except IOError as e:
# XXX: we have to distinguish unexpected errors from the expected ones
if e.errno == errno.EOPNOTSUPP:
# Since 3.5 memory.memsw.* are always created even if disabled.
# If disabled we will get EOPNOTSUPP when read or write them.
# See commit af36f906c0f4c2ffa0482ecdf856a33dc88ae8c5 of the kernel.
pass
if e.errno == errno.EIO:
# memory.kmem.slabinfo throws EIO until limit_in_bytes is set.
pass
else:
raise
return stats | python | def get_stats(self):
"""
It returns a name and a value pairs of control files
which are categorised in the stats group.
"""
stats = {}
for name, cls in self.stats.items():
path = self.paths[name]
if os.path.exists(path):
try:
stats[name] = self._PARSERS[cls](fileops.read(path))
except IOError as e:
# XXX: we have to distinguish unexpected errors from the expected ones
if e.errno == errno.EOPNOTSUPP:
# Since 3.5 memory.memsw.* are always created even if disabled.
# If disabled we will get EOPNOTSUPP when read or write them.
# See commit af36f906c0f4c2ffa0482ecdf856a33dc88ae8c5 of the kernel.
pass
if e.errno == errno.EIO:
# memory.kmem.slabinfo throws EIO until limit_in_bytes is set.
pass
else:
raise
return stats | [
"def",
"get_stats",
"(",
"self",
")",
":",
"stats",
"=",
"{",
"}",
"for",
"name",
",",
"cls",
"in",
"self",
".",
"stats",
".",
"items",
"(",
")",
":",
"path",
"=",
"self",
".",
"paths",
"[",
"name",
"]",
"if",
"os",
".",
"path",
".",
"exists",
... | It returns a name and a value pairs of control files
which are categorised in the stats group. | [
"It",
"returns",
"a",
"name",
"and",
"a",
"value",
"pairs",
"of",
"control",
"files",
"which",
"are",
"categorised",
"in",
"the",
"stats",
"group",
"."
] | fd7e99f438ce334bac5669fba0d08a6502fd7a82 | https://github.com/peo3/cgroup-utils/blob/fd7e99f438ce334bac5669fba0d08a6502fd7a82/cgutils/cgroup.py#L768-L791 | train |
peo3/cgroup-utils | cgutils/cgroup.py | CGroup.update | def update(self):
"""It updates process information of the cgroup."""
pids = fileops.readlines(self.paths['cgroup.procs'])
self.pids = [int(pid) for pid in pids if pid != '']
self.n_procs = len(pids) | python | def update(self):
"""It updates process information of the cgroup."""
pids = fileops.readlines(self.paths['cgroup.procs'])
self.pids = [int(pid) for pid in pids if pid != '']
self.n_procs = len(pids) | [
"def",
"update",
"(",
"self",
")",
":",
"pids",
"=",
"fileops",
".",
"readlines",
"(",
"self",
".",
"paths",
"[",
"'cgroup.procs'",
"]",
")",
"self",
".",
"pids",
"=",
"[",
"int",
"(",
"pid",
")",
"for",
"pid",
"in",
"pids",
"if",
"pid",
"!=",
"'... | It updates process information of the cgroup. | [
"It",
"updates",
"process",
"information",
"of",
"the",
"cgroup",
"."
] | fd7e99f438ce334bac5669fba0d08a6502fd7a82 | https://github.com/peo3/cgroup-utils/blob/fd7e99f438ce334bac5669fba0d08a6502fd7a82/cgutils/cgroup.py#L793-L797 | train |
peo3/cgroup-utils | cgutils/cgroup.py | EventListener.wait | def wait(self):
"""
It returns when an event which we have configured by set_threshold happens.
Note that it blocks until then.
"""
ret = os.read(self.event_fd, 64 / 8)
return struct.unpack('Q', ret) | python | def wait(self):
"""
It returns when an event which we have configured by set_threshold happens.
Note that it blocks until then.
"""
ret = os.read(self.event_fd, 64 / 8)
return struct.unpack('Q', ret) | [
"def",
"wait",
"(",
"self",
")",
":",
"ret",
"=",
"os",
".",
"read",
"(",
"self",
".",
"event_fd",
",",
"64",
"/",
"8",
")",
"return",
"struct",
".",
"unpack",
"(",
"'Q'",
",",
"ret",
")"
] | It returns when an event which we have configured by set_threshold happens.
Note that it blocks until then. | [
"It",
"returns",
"when",
"an",
"event",
"which",
"we",
"have",
"configured",
"by",
"set_threshold",
"happens",
".",
"Note",
"that",
"it",
"blocks",
"until",
"then",
"."
] | fd7e99f438ce334bac5669fba0d08a6502fd7a82 | https://github.com/peo3/cgroup-utils/blob/fd7e99f438ce334bac5669fba0d08a6502fd7a82/cgutils/cgroup.py#L887-L893 | train |
peakwinter/python-nginx | nginx.py | dumpf | def dumpf(obj, path):
"""
Write an nginx configuration to file.
:param obj obj: nginx object (Conf, Server, Container)
:param str path: path to nginx configuration on disk
:returns: path the configuration was written to
"""
with open(path, 'w') as f:
dump(obj, f)
return path | python | def dumpf(obj, path):
"""
Write an nginx configuration to file.
:param obj obj: nginx object (Conf, Server, Container)
:param str path: path to nginx configuration on disk
:returns: path the configuration was written to
"""
with open(path, 'w') as f:
dump(obj, f)
return path | [
"def",
"dumpf",
"(",
"obj",
",",
"path",
")",
":",
"with",
"open",
"(",
"path",
",",
"'w'",
")",
"as",
"f",
":",
"dump",
"(",
"obj",
",",
"f",
")",
"return",
"path"
] | Write an nginx configuration to file.
:param obj obj: nginx object (Conf, Server, Container)
:param str path: path to nginx configuration on disk
:returns: path the configuration was written to | [
"Write",
"an",
"nginx",
"configuration",
"to",
"file",
"."
] | 4ecd1cd2e1f11ffb633d188a578a004712eaae16 | https://github.com/peakwinter/python-nginx/blob/4ecd1cd2e1f11ffb633d188a578a004712eaae16/nginx.py#L581-L591 | train |
peakwinter/python-nginx | nginx.py | Conf.as_strings | def as_strings(self):
"""Return the entire Conf as nginx config strings."""
ret = []
for x in self.children:
if isinstance(x, (Key, Comment)):
ret.append(x.as_strings)
else:
for y in x.as_strings:
ret.append(y)
if ret:
ret[-1] = re.sub('}\n+$', '}\n', ret[-1])
return ret | python | def as_strings(self):
"""Return the entire Conf as nginx config strings."""
ret = []
for x in self.children:
if isinstance(x, (Key, Comment)):
ret.append(x.as_strings)
else:
for y in x.as_strings:
ret.append(y)
if ret:
ret[-1] = re.sub('}\n+$', '}\n', ret[-1])
return ret | [
"def",
"as_strings",
"(",
"self",
")",
":",
"ret",
"=",
"[",
"]",
"for",
"x",
"in",
"self",
".",
"children",
":",
"if",
"isinstance",
"(",
"x",
",",
"(",
"Key",
",",
"Comment",
")",
")",
":",
"ret",
".",
"append",
"(",
"x",
".",
"as_strings",
"... | Return the entire Conf as nginx config strings. | [
"Return",
"the",
"entire",
"Conf",
"as",
"nginx",
"config",
"strings",
"."
] | 4ecd1cd2e1f11ffb633d188a578a004712eaae16 | https://github.com/peakwinter/python-nginx/blob/4ecd1cd2e1f11ffb633d188a578a004712eaae16/nginx.py#L98-L109 | train |
peakwinter/python-nginx | nginx.py | Container.as_list | def as_list(self):
"""Return all child objects in nested lists of strings."""
return [self.name, self.value, [x.as_list for x in self.children]] | python | def as_list(self):
"""Return all child objects in nested lists of strings."""
return [self.name, self.value, [x.as_list for x in self.children]] | [
"def",
"as_list",
"(",
"self",
")",
":",
"return",
"[",
"self",
".",
"name",
",",
"self",
".",
"value",
",",
"[",
"x",
".",
"as_list",
"for",
"x",
"in",
"self",
".",
"children",
"]",
"]"
] | Return all child objects in nested lists of strings. | [
"Return",
"all",
"child",
"objects",
"in",
"nested",
"lists",
"of",
"strings",
"."
] | 4ecd1cd2e1f11ffb633d188a578a004712eaae16 | https://github.com/peakwinter/python-nginx/blob/4ecd1cd2e1f11ffb633d188a578a004712eaae16/nginx.py#L190-L192 | train |
peakwinter/python-nginx | nginx.py | Container.as_dict | def as_dict(self):
"""Return all child objects in nested dict."""
dicts = [x.as_dict for x in self.children]
return {'{0} {1}'.format(self.name, self.value): dicts} | python | def as_dict(self):
"""Return all child objects in nested dict."""
dicts = [x.as_dict for x in self.children]
return {'{0} {1}'.format(self.name, self.value): dicts} | [
"def",
"as_dict",
"(",
"self",
")",
":",
"dicts",
"=",
"[",
"x",
".",
"as_dict",
"for",
"x",
"in",
"self",
".",
"children",
"]",
"return",
"{",
"'{0} {1}'",
".",
"format",
"(",
"self",
".",
"name",
",",
"self",
".",
"value",
")",
":",
"dicts",
"}... | Return all child objects in nested dict. | [
"Return",
"all",
"child",
"objects",
"in",
"nested",
"dict",
"."
] | 4ecd1cd2e1f11ffb633d188a578a004712eaae16 | https://github.com/peakwinter/python-nginx/blob/4ecd1cd2e1f11ffb633d188a578a004712eaae16/nginx.py#L195-L198 | train |
peakwinter/python-nginx | nginx.py | Container.as_strings | def as_strings(self):
"""Return the entire Container as nginx config strings."""
ret = []
container_title = (INDENT * self._depth)
container_title += '{0}{1} {{\n'.format(
self.name, (' {0}'.format(self.value) if self.value else '')
)
ret.append(container_title)
for x in self.children:
if isinstance(x, Key):
ret.append(INDENT + x.as_strings)
elif isinstance(x, Comment):
if x.inline and len(ret) >= 1:
ret[-1] = ret[-1].rstrip('\n') + ' ' + x.as_strings
else:
ret.append(INDENT + x.as_strings)
elif isinstance(x, Container):
y = x.as_strings
ret.append('\n' + y[0])
for z in y[1:]:
ret.append(INDENT + z)
else:
y = x.as_strings
ret.append(INDENT + y)
ret[-1] = re.sub('}\n+$', '}\n', ret[-1])
ret.append('}\n\n')
return ret | python | def as_strings(self):
"""Return the entire Container as nginx config strings."""
ret = []
container_title = (INDENT * self._depth)
container_title += '{0}{1} {{\n'.format(
self.name, (' {0}'.format(self.value) if self.value else '')
)
ret.append(container_title)
for x in self.children:
if isinstance(x, Key):
ret.append(INDENT + x.as_strings)
elif isinstance(x, Comment):
if x.inline and len(ret) >= 1:
ret[-1] = ret[-1].rstrip('\n') + ' ' + x.as_strings
else:
ret.append(INDENT + x.as_strings)
elif isinstance(x, Container):
y = x.as_strings
ret.append('\n' + y[0])
for z in y[1:]:
ret.append(INDENT + z)
else:
y = x.as_strings
ret.append(INDENT + y)
ret[-1] = re.sub('}\n+$', '}\n', ret[-1])
ret.append('}\n\n')
return ret | [
"def",
"as_strings",
"(",
"self",
")",
":",
"ret",
"=",
"[",
"]",
"container_title",
"=",
"(",
"INDENT",
"*",
"self",
".",
"_depth",
")",
"container_title",
"+=",
"'{0}{1} {{\\n'",
".",
"format",
"(",
"self",
".",
"name",
",",
"(",
"' {0}'",
".",
"form... | Return the entire Container as nginx config strings. | [
"Return",
"the",
"entire",
"Container",
"as",
"nginx",
"config",
"strings",
"."
] | 4ecd1cd2e1f11ffb633d188a578a004712eaae16 | https://github.com/peakwinter/python-nginx/blob/4ecd1cd2e1f11ffb633d188a578a004712eaae16/nginx.py#L201-L227 | train |
peakwinter/python-nginx | nginx.py | Key.as_strings | def as_strings(self):
"""Return key as nginx config string."""
if self.value == '' or self.value is None:
return '{0};\n'.format(self.name)
if '"' not in self.value and (';' in self.value or '#' in self.value):
return '{0} "{1}";\n'.format(self.name, self.value)
return '{0} {1};\n'.format(self.name, self.value) | python | def as_strings(self):
"""Return key as nginx config string."""
if self.value == '' or self.value is None:
return '{0};\n'.format(self.name)
if '"' not in self.value and (';' in self.value or '#' in self.value):
return '{0} "{1}";\n'.format(self.name, self.value)
return '{0} {1};\n'.format(self.name, self.value) | [
"def",
"as_strings",
"(",
"self",
")",
":",
"if",
"self",
".",
"value",
"==",
"''",
"or",
"self",
".",
"value",
"is",
"None",
":",
"return",
"'{0};\\n'",
".",
"format",
"(",
"self",
".",
"name",
")",
"if",
"'\"'",
"not",
"in",
"self",
".",
"value",... | Return key as nginx config string. | [
"Return",
"key",
"as",
"nginx",
"config",
"string",
"."
] | 4ecd1cd2e1f11ffb633d188a578a004712eaae16 | https://github.com/peakwinter/python-nginx/blob/4ecd1cd2e1f11ffb633d188a578a004712eaae16/nginx.py#L390-L396 | train |
yougov/elastic2-doc-manager | mongo_connector/doc_managers/elastic2_doc_manager.py | convert_aws_args | def convert_aws_args(aws_args):
"""Convert old style options into arguments to boto3.session.Session."""
if not isinstance(aws_args, dict):
raise errors.InvalidConfiguration(
'Elastic DocManager config option "aws" must be a dict'
)
old_session_kwargs = dict(
region="region_name",
access_id="aws_access_key_id",
secret_key="aws_secret_access_key",
)
new_kwargs = {}
for arg in aws_args:
if arg in old_session_kwargs:
new_kwargs[old_session_kwargs[arg]] = aws_args[arg]
else:
new_kwargs[arg] = aws_args[arg]
return new_kwargs | python | def convert_aws_args(aws_args):
"""Convert old style options into arguments to boto3.session.Session."""
if not isinstance(aws_args, dict):
raise errors.InvalidConfiguration(
'Elastic DocManager config option "aws" must be a dict'
)
old_session_kwargs = dict(
region="region_name",
access_id="aws_access_key_id",
secret_key="aws_secret_access_key",
)
new_kwargs = {}
for arg in aws_args:
if arg in old_session_kwargs:
new_kwargs[old_session_kwargs[arg]] = aws_args[arg]
else:
new_kwargs[arg] = aws_args[arg]
return new_kwargs | [
"def",
"convert_aws_args",
"(",
"aws_args",
")",
":",
"if",
"not",
"isinstance",
"(",
"aws_args",
",",
"dict",
")",
":",
"raise",
"errors",
".",
"InvalidConfiguration",
"(",
"'Elastic DocManager config option \"aws\" must be a dict'",
")",
"old_session_kwargs",
"=",
"... | Convert old style options into arguments to boto3.session.Session. | [
"Convert",
"old",
"style",
"options",
"into",
"arguments",
"to",
"boto3",
".",
"session",
".",
"Session",
"."
] | ad92138d1fd6656bb2e71cb5cc840f9ba0109c49 | https://github.com/yougov/elastic2-doc-manager/blob/ad92138d1fd6656bb2e71cb5cc840f9ba0109c49/mongo_connector/doc_managers/elastic2_doc_manager.py#L82-L99 | train |
yougov/elastic2-doc-manager | mongo_connector/doc_managers/elastic2_doc_manager.py | DocManager._index_and_mapping | def _index_and_mapping(self, namespace):
"""Helper method for getting the index and type from a namespace."""
index, doc_type = namespace.split(".", 1)
return index.lower(), doc_type | python | def _index_and_mapping(self, namespace):
"""Helper method for getting the index and type from a namespace."""
index, doc_type = namespace.split(".", 1)
return index.lower(), doc_type | [
"def",
"_index_and_mapping",
"(",
"self",
",",
"namespace",
")",
":",
"index",
",",
"doc_type",
"=",
"namespace",
".",
"split",
"(",
"\".\"",
",",
"1",
")",
"return",
"index",
".",
"lower",
"(",
")",
",",
"doc_type"
] | Helper method for getting the index and type from a namespace. | [
"Helper",
"method",
"for",
"getting",
"the",
"index",
"and",
"type",
"from",
"a",
"namespace",
"."
] | ad92138d1fd6656bb2e71cb5cc840f9ba0109c49 | https://github.com/yougov/elastic2-doc-manager/blob/ad92138d1fd6656bb2e71cb5cc840f9ba0109c49/mongo_connector/doc_managers/elastic2_doc_manager.py#L226-L229 | train |
yougov/elastic2-doc-manager | mongo_connector/doc_managers/elastic2_doc_manager.py | DocManager._stream_search | def _stream_search(self, *args, **kwargs):
"""Helper method for iterating over ES search results."""
for hit in scan(
self.elastic, query=kwargs.pop("body", None), scroll="10m", **kwargs
):
hit["_source"]["_id"] = hit["_id"]
yield hit["_source"] | python | def _stream_search(self, *args, **kwargs):
"""Helper method for iterating over ES search results."""
for hit in scan(
self.elastic, query=kwargs.pop("body", None), scroll="10m", **kwargs
):
hit["_source"]["_id"] = hit["_id"]
yield hit["_source"] | [
"def",
"_stream_search",
"(",
"self",
",",
"*",
"args",
",",
"**",
"kwargs",
")",
":",
"for",
"hit",
"in",
"scan",
"(",
"self",
".",
"elastic",
",",
"query",
"=",
"kwargs",
".",
"pop",
"(",
"\"body\"",
",",
"None",
")",
",",
"scroll",
"=",
"\"10m\"... | Helper method for iterating over ES search results. | [
"Helper",
"method",
"for",
"iterating",
"over",
"ES",
"search",
"results",
"."
] | ad92138d1fd6656bb2e71cb5cc840f9ba0109c49 | https://github.com/yougov/elastic2-doc-manager/blob/ad92138d1fd6656bb2e71cb5cc840f9ba0109c49/mongo_connector/doc_managers/elastic2_doc_manager.py#L458-L464 | train |
yougov/elastic2-doc-manager | mongo_connector/doc_managers/elastic2_doc_manager.py | DocManager.search | def search(self, start_ts, end_ts):
"""Query Elasticsearch for documents in a time range.
This method is used to find documents that may be in conflict during
a rollback event in MongoDB.
"""
return self._stream_search(
index=self.meta_index_name,
body={"query": {"range": {"_ts": {"gte": start_ts, "lte": end_ts}}}},
) | python | def search(self, start_ts, end_ts):
"""Query Elasticsearch for documents in a time range.
This method is used to find documents that may be in conflict during
a rollback event in MongoDB.
"""
return self._stream_search(
index=self.meta_index_name,
body={"query": {"range": {"_ts": {"gte": start_ts, "lte": end_ts}}}},
) | [
"def",
"search",
"(",
"self",
",",
"start_ts",
",",
"end_ts",
")",
":",
"return",
"self",
".",
"_stream_search",
"(",
"index",
"=",
"self",
".",
"meta_index_name",
",",
"body",
"=",
"{",
"\"query\"",
":",
"{",
"\"range\"",
":",
"{",
"\"_ts\"",
":",
"{"... | Query Elasticsearch for documents in a time range.
This method is used to find documents that may be in conflict during
a rollback event in MongoDB. | [
"Query",
"Elasticsearch",
"for",
"documents",
"in",
"a",
"time",
"range",
"."
] | ad92138d1fd6656bb2e71cb5cc840f9ba0109c49 | https://github.com/yougov/elastic2-doc-manager/blob/ad92138d1fd6656bb2e71cb5cc840f9ba0109c49/mongo_connector/doc_managers/elastic2_doc_manager.py#L466-L475 | train |
yougov/elastic2-doc-manager | mongo_connector/doc_managers/elastic2_doc_manager.py | DocManager.commit | def commit(self):
"""Send buffered requests and refresh all indexes."""
self.send_buffered_operations()
retry_until_ok(self.elastic.indices.refresh, index="") | python | def commit(self):
"""Send buffered requests and refresh all indexes."""
self.send_buffered_operations()
retry_until_ok(self.elastic.indices.refresh, index="") | [
"def",
"commit",
"(",
"self",
")",
":",
"self",
".",
"send_buffered_operations",
"(",
")",
"retry_until_ok",
"(",
"self",
".",
"elastic",
".",
"indices",
".",
"refresh",
",",
"index",
"=",
"\"\"",
")"
] | Send buffered requests and refresh all indexes. | [
"Send",
"buffered",
"requests",
"and",
"refresh",
"all",
"indexes",
"."
] | ad92138d1fd6656bb2e71cb5cc840f9ba0109c49 | https://github.com/yougov/elastic2-doc-manager/blob/ad92138d1fd6656bb2e71cb5cc840f9ba0109c49/mongo_connector/doc_managers/elastic2_doc_manager.py#L507-L510 | train |
yougov/elastic2-doc-manager | mongo_connector/doc_managers/elastic2_doc_manager.py | BulkBuffer.add_upsert | def add_upsert(self, action, meta_action, doc_source, update_spec):
"""
Function which stores sources for "insert" actions
and decide if for "update" action has to add docs to
get source buffer
"""
# Whenever update_spec is provided to this method
# it means that doc source needs to be retrieved
# from Elasticsearch. It means also that source
# is not stored in local buffer
if update_spec:
self.bulk_index(action, meta_action)
# -1 -> to get latest index number
# -1 -> to get action instead of meta_action
# Update document based on source retrieved from ES
self.add_doc_to_update(action, update_spec, len(self.action_buffer) - 2)
else:
# Insert and update operations provide source
# Store it in local buffer and use for comming updates
# inside same buffer
# add_to_sources will not be called for delete operation
# as it does not provide doc_source
if doc_source:
self.add_to_sources(action, doc_source)
self.bulk_index(action, meta_action) | python | def add_upsert(self, action, meta_action, doc_source, update_spec):
"""
Function which stores sources for "insert" actions
and decide if for "update" action has to add docs to
get source buffer
"""
# Whenever update_spec is provided to this method
# it means that doc source needs to be retrieved
# from Elasticsearch. It means also that source
# is not stored in local buffer
if update_spec:
self.bulk_index(action, meta_action)
# -1 -> to get latest index number
# -1 -> to get action instead of meta_action
# Update document based on source retrieved from ES
self.add_doc_to_update(action, update_spec, len(self.action_buffer) - 2)
else:
# Insert and update operations provide source
# Store it in local buffer and use for comming updates
# inside same buffer
# add_to_sources will not be called for delete operation
# as it does not provide doc_source
if doc_source:
self.add_to_sources(action, doc_source)
self.bulk_index(action, meta_action) | [
"def",
"add_upsert",
"(",
"self",
",",
"action",
",",
"meta_action",
",",
"doc_source",
",",
"update_spec",
")",
":",
"if",
"update_spec",
":",
"self",
".",
"bulk_index",
"(",
"action",
",",
"meta_action",
")",
"self",
".",
"add_doc_to_update",
"(",
"action"... | Function which stores sources for "insert" actions
and decide if for "update" action has to add docs to
get source buffer | [
"Function",
"which",
"stores",
"sources",
"for",
"insert",
"actions",
"and",
"decide",
"if",
"for",
"update",
"action",
"has",
"to",
"add",
"docs",
"to",
"get",
"source",
"buffer"
] | ad92138d1fd6656bb2e71cb5cc840f9ba0109c49 | https://github.com/yougov/elastic2-doc-manager/blob/ad92138d1fd6656bb2e71cb5cc840f9ba0109c49/mongo_connector/doc_managers/elastic2_doc_manager.py#L559-L585 | train |
yougov/elastic2-doc-manager | mongo_connector/doc_managers/elastic2_doc_manager.py | BulkBuffer.add_doc_to_update | def add_doc_to_update(self, action, update_spec, action_buffer_index):
"""
Prepare document for update based on Elasticsearch response.
Set flag if document needs to be retrieved from Elasticsearch
"""
doc = {
"_index": action["_index"],
"_type": action["_type"],
"_id": action["_id"],
}
# If get_from_ES == True -> get document's source from Elasticsearch
get_from_ES = self.should_get_id(action)
self.doc_to_update.append((doc, update_spec, action_buffer_index, get_from_ES)) | python | def add_doc_to_update(self, action, update_spec, action_buffer_index):
"""
Prepare document for update based on Elasticsearch response.
Set flag if document needs to be retrieved from Elasticsearch
"""
doc = {
"_index": action["_index"],
"_type": action["_type"],
"_id": action["_id"],
}
# If get_from_ES == True -> get document's source from Elasticsearch
get_from_ES = self.should_get_id(action)
self.doc_to_update.append((doc, update_spec, action_buffer_index, get_from_ES)) | [
"def",
"add_doc_to_update",
"(",
"self",
",",
"action",
",",
"update_spec",
",",
"action_buffer_index",
")",
":",
"doc",
"=",
"{",
"\"_index\"",
":",
"action",
"[",
"\"_index\"",
"]",
",",
"\"_type\"",
":",
"action",
"[",
"\"_type\"",
"]",
",",
"\"_id\"",
... | Prepare document for update based on Elasticsearch response.
Set flag if document needs to be retrieved from Elasticsearch | [
"Prepare",
"document",
"for",
"update",
"based",
"on",
"Elasticsearch",
"response",
".",
"Set",
"flag",
"if",
"document",
"needs",
"to",
"be",
"retrieved",
"from",
"Elasticsearch"
] | ad92138d1fd6656bb2e71cb5cc840f9ba0109c49 | https://github.com/yougov/elastic2-doc-manager/blob/ad92138d1fd6656bb2e71cb5cc840f9ba0109c49/mongo_connector/doc_managers/elastic2_doc_manager.py#L587-L601 | train |
yougov/elastic2-doc-manager | mongo_connector/doc_managers/elastic2_doc_manager.py | BulkBuffer.get_docs_sources_from_ES | def get_docs_sources_from_ES(self):
"""Get document sources using MGET elasticsearch API"""
docs = [doc for doc, _, _, get_from_ES in self.doc_to_update if get_from_ES]
if docs:
documents = self.docman.elastic.mget(body={"docs": docs}, realtime=True)
return iter(documents["docs"])
else:
return iter([]) | python | def get_docs_sources_from_ES(self):
"""Get document sources using MGET elasticsearch API"""
docs = [doc for doc, _, _, get_from_ES in self.doc_to_update if get_from_ES]
if docs:
documents = self.docman.elastic.mget(body={"docs": docs}, realtime=True)
return iter(documents["docs"])
else:
return iter([]) | [
"def",
"get_docs_sources_from_ES",
"(",
"self",
")",
":",
"docs",
"=",
"[",
"doc",
"for",
"doc",
",",
"_",
",",
"_",
",",
"get_from_ES",
"in",
"self",
".",
"doc_to_update",
"if",
"get_from_ES",
"]",
"if",
"docs",
":",
"documents",
"=",
"self",
".",
"do... | Get document sources using MGET elasticsearch API | [
"Get",
"document",
"sources",
"using",
"MGET",
"elasticsearch",
"API"
] | ad92138d1fd6656bb2e71cb5cc840f9ba0109c49 | https://github.com/yougov/elastic2-doc-manager/blob/ad92138d1fd6656bb2e71cb5cc840f9ba0109c49/mongo_connector/doc_managers/elastic2_doc_manager.py#L620-L627 | train |
yougov/elastic2-doc-manager | mongo_connector/doc_managers/elastic2_doc_manager.py | BulkBuffer.update_sources | def update_sources(self):
"""Update local sources based on response from Elasticsearch"""
ES_documents = self.get_docs_sources_from_ES()
for doc, update_spec, action_buffer_index, get_from_ES in self.doc_to_update:
if get_from_ES:
# Update source based on response from ES
ES_doc = next(ES_documents)
if ES_doc["found"]:
source = ES_doc["_source"]
else:
# Document not found in elasticsearch,
# Seems like something went wrong during replication
LOG.error(
"mGET: Document id: %s has not been found "
"in Elasticsearch. Due to that "
"following update failed: %s",
doc["_id"],
update_spec,
)
self.reset_action(action_buffer_index)
continue
else:
# Get source stored locally before applying update
# as it is up-to-date
source = self.get_from_sources(doc["_index"], doc["_type"], doc["_id"])
if not source:
LOG.error(
"mGET: Document id: %s has not been found "
"in local sources. Due to that following "
"update failed: %s",
doc["_id"],
update_spec,
)
self.reset_action(action_buffer_index)
continue
updated = self.docman.apply_update(source, update_spec)
# Remove _id field from source
if "_id" in updated:
del updated["_id"]
# Everytime update locally stored sources to keep them up-to-date
self.add_to_sources(doc, updated)
self.action_buffer[action_buffer_index][
"_source"
] = self.docman._formatter.format_document(updated)
# Remove empty actions if there were errors
self.action_buffer = [
each_action for each_action in self.action_buffer if each_action
] | python | def update_sources(self):
"""Update local sources based on response from Elasticsearch"""
ES_documents = self.get_docs_sources_from_ES()
for doc, update_spec, action_buffer_index, get_from_ES in self.doc_to_update:
if get_from_ES:
# Update source based on response from ES
ES_doc = next(ES_documents)
if ES_doc["found"]:
source = ES_doc["_source"]
else:
# Document not found in elasticsearch,
# Seems like something went wrong during replication
LOG.error(
"mGET: Document id: %s has not been found "
"in Elasticsearch. Due to that "
"following update failed: %s",
doc["_id"],
update_spec,
)
self.reset_action(action_buffer_index)
continue
else:
# Get source stored locally before applying update
# as it is up-to-date
source = self.get_from_sources(doc["_index"], doc["_type"], doc["_id"])
if not source:
LOG.error(
"mGET: Document id: %s has not been found "
"in local sources. Due to that following "
"update failed: %s",
doc["_id"],
update_spec,
)
self.reset_action(action_buffer_index)
continue
updated = self.docman.apply_update(source, update_spec)
# Remove _id field from source
if "_id" in updated:
del updated["_id"]
# Everytime update locally stored sources to keep them up-to-date
self.add_to_sources(doc, updated)
self.action_buffer[action_buffer_index][
"_source"
] = self.docman._formatter.format_document(updated)
# Remove empty actions if there were errors
self.action_buffer = [
each_action for each_action in self.action_buffer if each_action
] | [
"def",
"update_sources",
"(",
"self",
")",
":",
"ES_documents",
"=",
"self",
".",
"get_docs_sources_from_ES",
"(",
")",
"for",
"doc",
",",
"update_spec",
",",
"action_buffer_index",
",",
"get_from_ES",
"in",
"self",
".",
"doc_to_update",
":",
"if",
"get_from_ES"... | Update local sources based on response from Elasticsearch | [
"Update",
"local",
"sources",
"based",
"on",
"response",
"from",
"Elasticsearch"
] | ad92138d1fd6656bb2e71cb5cc840f9ba0109c49 | https://github.com/yougov/elastic2-doc-manager/blob/ad92138d1fd6656bb2e71cb5cc840f9ba0109c49/mongo_connector/doc_managers/elastic2_doc_manager.py#L630-L683 | train |
yougov/elastic2-doc-manager | mongo_connector/doc_managers/elastic2_doc_manager.py | BulkBuffer.add_to_sources | def add_to_sources(self, action, doc_source):
"""Store sources locally"""
mapping = self.sources.setdefault(action["_index"], {}).setdefault(
action["_type"], {}
)
mapping[action["_id"]] = doc_source | python | def add_to_sources(self, action, doc_source):
"""Store sources locally"""
mapping = self.sources.setdefault(action["_index"], {}).setdefault(
action["_type"], {}
)
mapping[action["_id"]] = doc_source | [
"def",
"add_to_sources",
"(",
"self",
",",
"action",
",",
"doc_source",
")",
":",
"mapping",
"=",
"self",
".",
"sources",
".",
"setdefault",
"(",
"action",
"[",
"\"_index\"",
"]",
",",
"{",
"}",
")",
".",
"setdefault",
"(",
"action",
"[",
"\"_type\"",
... | Store sources locally | [
"Store",
"sources",
"locally"
] | ad92138d1fd6656bb2e71cb5cc840f9ba0109c49 | https://github.com/yougov/elastic2-doc-manager/blob/ad92138d1fd6656bb2e71cb5cc840f9ba0109c49/mongo_connector/doc_managers/elastic2_doc_manager.py#L690-L695 | train |
yougov/elastic2-doc-manager | mongo_connector/doc_managers/elastic2_doc_manager.py | BulkBuffer.get_from_sources | def get_from_sources(self, index, doc_type, document_id):
"""Get source stored locally"""
return self.sources.get(index, {}).get(doc_type, {}).get(document_id, {}) | python | def get_from_sources(self, index, doc_type, document_id):
"""Get source stored locally"""
return self.sources.get(index, {}).get(doc_type, {}).get(document_id, {}) | [
"def",
"get_from_sources",
"(",
"self",
",",
"index",
",",
"doc_type",
",",
"document_id",
")",
":",
"return",
"self",
".",
"sources",
".",
"get",
"(",
"index",
",",
"{",
"}",
")",
".",
"get",
"(",
"doc_type",
",",
"{",
"}",
")",
".",
"get",
"(",
... | Get source stored locally | [
"Get",
"source",
"stored",
"locally"
] | ad92138d1fd6656bb2e71cb5cc840f9ba0109c49 | https://github.com/yougov/elastic2-doc-manager/blob/ad92138d1fd6656bb2e71cb5cc840f9ba0109c49/mongo_connector/doc_managers/elastic2_doc_manager.py#L697-L699 | train |
yougov/elastic2-doc-manager | mongo_connector/doc_managers/elastic2_doc_manager.py | BulkBuffer.clean_up | def clean_up(self):
"""Do clean-up before returning buffer"""
self.action_buffer = []
self.sources = {}
self.doc_to_get = {}
self.doc_to_update = [] | python | def clean_up(self):
"""Do clean-up before returning buffer"""
self.action_buffer = []
self.sources = {}
self.doc_to_get = {}
self.doc_to_update = [] | [
"def",
"clean_up",
"(",
"self",
")",
":",
"self",
".",
"action_buffer",
"=",
"[",
"]",
"self",
".",
"sources",
"=",
"{",
"}",
"self",
".",
"doc_to_get",
"=",
"{",
"}",
"self",
".",
"doc_to_update",
"=",
"[",
"]"
] | Do clean-up before returning buffer | [
"Do",
"clean",
"-",
"up",
"before",
"returning",
"buffer"
] | ad92138d1fd6656bb2e71cb5cc840f9ba0109c49 | https://github.com/yougov/elastic2-doc-manager/blob/ad92138d1fd6656bb2e71cb5cc840f9ba0109c49/mongo_connector/doc_managers/elastic2_doc_manager.py#L705-L710 | train |
yougov/elastic2-doc-manager | mongo_connector/doc_managers/elastic2_doc_manager.py | BulkBuffer.get_buffer | def get_buffer(self):
"""Get buffer which needs to be bulked to elasticsearch"""
# Get sources for documents which are in Elasticsearch
# and they are not in local buffer
if self.doc_to_update:
self.update_sources()
ES_buffer = self.action_buffer
self.clean_up()
return ES_buffer | python | def get_buffer(self):
"""Get buffer which needs to be bulked to elasticsearch"""
# Get sources for documents which are in Elasticsearch
# and they are not in local buffer
if self.doc_to_update:
self.update_sources()
ES_buffer = self.action_buffer
self.clean_up()
return ES_buffer | [
"def",
"get_buffer",
"(",
"self",
")",
":",
"if",
"self",
".",
"doc_to_update",
":",
"self",
".",
"update_sources",
"(",
")",
"ES_buffer",
"=",
"self",
".",
"action_buffer",
"self",
".",
"clean_up",
"(",
")",
"return",
"ES_buffer"
] | Get buffer which needs to be bulked to elasticsearch | [
"Get",
"buffer",
"which",
"needs",
"to",
"be",
"bulked",
"to",
"elasticsearch"
] | ad92138d1fd6656bb2e71cb5cc840f9ba0109c49 | https://github.com/yougov/elastic2-doc-manager/blob/ad92138d1fd6656bb2e71cb5cc840f9ba0109c49/mongo_connector/doc_managers/elastic2_doc_manager.py#L712-L722 | train |
citruz/beacontools | beacontools/scanner.py | Monitor.run | def run(self):
"""Continously scan for BLE advertisements."""
self.socket = self.bluez.hci_open_dev(self.bt_device_id)
filtr = self.bluez.hci_filter_new()
self.bluez.hci_filter_all_events(filtr)
self.bluez.hci_filter_set_ptype(filtr, self.bluez.HCI_EVENT_PKT)
self.socket.setsockopt(self.bluez.SOL_HCI, self.bluez.HCI_FILTER, filtr)
self.set_scan_parameters()
self.toggle_scan(True)
while self.keep_going:
pkt = self.socket.recv(255)
event = to_int(pkt[1])
subevent = to_int(pkt[3])
if event == LE_META_EVENT and subevent == EVT_LE_ADVERTISING_REPORT:
# we have an BLE advertisement
self.process_packet(pkt)
self.socket.close() | python | def run(self):
"""Continously scan for BLE advertisements."""
self.socket = self.bluez.hci_open_dev(self.bt_device_id)
filtr = self.bluez.hci_filter_new()
self.bluez.hci_filter_all_events(filtr)
self.bluez.hci_filter_set_ptype(filtr, self.bluez.HCI_EVENT_PKT)
self.socket.setsockopt(self.bluez.SOL_HCI, self.bluez.HCI_FILTER, filtr)
self.set_scan_parameters()
self.toggle_scan(True)
while self.keep_going:
pkt = self.socket.recv(255)
event = to_int(pkt[1])
subevent = to_int(pkt[3])
if event == LE_META_EVENT and subevent == EVT_LE_ADVERTISING_REPORT:
# we have an BLE advertisement
self.process_packet(pkt)
self.socket.close() | [
"def",
"run",
"(",
"self",
")",
":",
"self",
".",
"socket",
"=",
"self",
".",
"bluez",
".",
"hci_open_dev",
"(",
"self",
".",
"bt_device_id",
")",
"filtr",
"=",
"self",
".",
"bluez",
".",
"hci_filter_new",
"(",
")",
"self",
".",
"bluez",
".",
"hci_fi... | Continously scan for BLE advertisements. | [
"Continously",
"scan",
"for",
"BLE",
"advertisements",
"."
] | 15a83e9750d0a4393f8a36868e07f6d9458253fe | https://github.com/citruz/beacontools/blob/15a83e9750d0a4393f8a36868e07f6d9458253fe/beacontools/scanner.py#L89-L108 | train |
citruz/beacontools | beacontools/scanner.py | Monitor.set_scan_parameters | def set_scan_parameters(self, scan_type=ScanType.ACTIVE, interval_ms=10, window_ms=10,
address_type=BluetoothAddressType.RANDOM, filter_type=ScanFilter.ALL):
""""sets the le scan parameters
Args:
scan_type: ScanType.(PASSIVE|ACTIVE)
interval: ms (as float) between scans (valid range 2.5ms - 10240ms)
..note:: when interval and window are equal, the scan
runs continuos
window: ms (as float) scan duration (valid range 2.5ms - 10240ms)
address_type: Bluetooth address type BluetoothAddressType.(PUBLIC|RANDOM)
* PUBLIC = use device MAC address
* RANDOM = generate a random MAC address and use that
filter: ScanFilter.(ALL|WHITELIST_ONLY) only ALL is supported, which will
return all fetched bluetooth packets (WHITELIST_ONLY is not supported,
because OCF_LE_ADD_DEVICE_TO_WHITE_LIST command is not implemented)
Raises:
ValueError: A value had an unexpected format or was not in range
"""
interval_fractions = interval_ms / MS_FRACTION_DIVIDER
if interval_fractions < 0x0004 or interval_fractions > 0x4000:
raise ValueError(
"Invalid interval given {}, must be in range of 2.5ms to 10240ms!".format(
interval_fractions))
window_fractions = window_ms / MS_FRACTION_DIVIDER
if window_fractions < 0x0004 or window_fractions > 0x4000:
raise ValueError(
"Invalid window given {}, must be in range of 2.5ms to 10240ms!".format(
window_fractions))
interval_fractions, window_fractions = int(interval_fractions), int(window_fractions)
scan_parameter_pkg = struct.pack(
">BHHBB",
scan_type,
interval_fractions,
window_fractions,
address_type,
filter_type)
self.bluez.hci_send_cmd(self.socket, OGF_LE_CTL, OCF_LE_SET_SCAN_PARAMETERS,
scan_parameter_pkg) | python | def set_scan_parameters(self, scan_type=ScanType.ACTIVE, interval_ms=10, window_ms=10,
address_type=BluetoothAddressType.RANDOM, filter_type=ScanFilter.ALL):
""""sets the le scan parameters
Args:
scan_type: ScanType.(PASSIVE|ACTIVE)
interval: ms (as float) between scans (valid range 2.5ms - 10240ms)
..note:: when interval and window are equal, the scan
runs continuos
window: ms (as float) scan duration (valid range 2.5ms - 10240ms)
address_type: Bluetooth address type BluetoothAddressType.(PUBLIC|RANDOM)
* PUBLIC = use device MAC address
* RANDOM = generate a random MAC address and use that
filter: ScanFilter.(ALL|WHITELIST_ONLY) only ALL is supported, which will
return all fetched bluetooth packets (WHITELIST_ONLY is not supported,
because OCF_LE_ADD_DEVICE_TO_WHITE_LIST command is not implemented)
Raises:
ValueError: A value had an unexpected format or was not in range
"""
interval_fractions = interval_ms / MS_FRACTION_DIVIDER
if interval_fractions < 0x0004 or interval_fractions > 0x4000:
raise ValueError(
"Invalid interval given {}, must be in range of 2.5ms to 10240ms!".format(
interval_fractions))
window_fractions = window_ms / MS_FRACTION_DIVIDER
if window_fractions < 0x0004 or window_fractions > 0x4000:
raise ValueError(
"Invalid window given {}, must be in range of 2.5ms to 10240ms!".format(
window_fractions))
interval_fractions, window_fractions = int(interval_fractions), int(window_fractions)
scan_parameter_pkg = struct.pack(
">BHHBB",
scan_type,
interval_fractions,
window_fractions,
address_type,
filter_type)
self.bluez.hci_send_cmd(self.socket, OGF_LE_CTL, OCF_LE_SET_SCAN_PARAMETERS,
scan_parameter_pkg) | [
"def",
"set_scan_parameters",
"(",
"self",
",",
"scan_type",
"=",
"ScanType",
".",
"ACTIVE",
",",
"interval_ms",
"=",
"10",
",",
"window_ms",
"=",
"10",
",",
"address_type",
"=",
"BluetoothAddressType",
".",
"RANDOM",
",",
"filter_type",
"=",
"ScanFilter",
"."... | sets the le scan parameters
Args:
scan_type: ScanType.(PASSIVE|ACTIVE)
interval: ms (as float) between scans (valid range 2.5ms - 10240ms)
..note:: when interval and window are equal, the scan
runs continuos
window: ms (as float) scan duration (valid range 2.5ms - 10240ms)
address_type: Bluetooth address type BluetoothAddressType.(PUBLIC|RANDOM)
* PUBLIC = use device MAC address
* RANDOM = generate a random MAC address and use that
filter: ScanFilter.(ALL|WHITELIST_ONLY) only ALL is supported, which will
return all fetched bluetooth packets (WHITELIST_ONLY is not supported,
because OCF_LE_ADD_DEVICE_TO_WHITE_LIST command is not implemented)
Raises:
ValueError: A value had an unexpected format or was not in range | [
"sets",
"the",
"le",
"scan",
"parameters"
] | 15a83e9750d0a4393f8a36868e07f6d9458253fe | https://github.com/citruz/beacontools/blob/15a83e9750d0a4393f8a36868e07f6d9458253fe/beacontools/scanner.py#L110-L151 | train |
citruz/beacontools | beacontools/scanner.py | Monitor.toggle_scan | def toggle_scan(self, enable, filter_duplicates=False):
"""Enables or disables BLE scanning
Args:
enable: boolean value to enable (True) or disable (False) scanner
filter_duplicates: boolean value to enable/disable filter, that
omits duplicated packets"""
command = struct.pack(">BB", enable, filter_duplicates)
self.bluez.hci_send_cmd(self.socket, OGF_LE_CTL, OCF_LE_SET_SCAN_ENABLE, command) | python | def toggle_scan(self, enable, filter_duplicates=False):
"""Enables or disables BLE scanning
Args:
enable: boolean value to enable (True) or disable (False) scanner
filter_duplicates: boolean value to enable/disable filter, that
omits duplicated packets"""
command = struct.pack(">BB", enable, filter_duplicates)
self.bluez.hci_send_cmd(self.socket, OGF_LE_CTL, OCF_LE_SET_SCAN_ENABLE, command) | [
"def",
"toggle_scan",
"(",
"self",
",",
"enable",
",",
"filter_duplicates",
"=",
"False",
")",
":",
"command",
"=",
"struct",
".",
"pack",
"(",
"\">BB\"",
",",
"enable",
",",
"filter_duplicates",
")",
"self",
".",
"bluez",
".",
"hci_send_cmd",
"(",
"self",... | Enables or disables BLE scanning
Args:
enable: boolean value to enable (True) or disable (False) scanner
filter_duplicates: boolean value to enable/disable filter, that
omits duplicated packets | [
"Enables",
"or",
"disables",
"BLE",
"scanning"
] | 15a83e9750d0a4393f8a36868e07f6d9458253fe | https://github.com/citruz/beacontools/blob/15a83e9750d0a4393f8a36868e07f6d9458253fe/beacontools/scanner.py#L153-L161 | train |
citruz/beacontools | beacontools/scanner.py | Monitor.process_packet | def process_packet(self, pkt):
"""Parse the packet and call callback if one of the filters matches."""
# check if this could be a valid packet before parsing
# this reduces the CPU load significantly
if not ( \
((self.mode & ScannerMode.MODE_IBEACON) and (pkt[19:23] == b"\x4c\x00\x02\x15")) or \
((self.mode & ScannerMode.MODE_EDDYSTONE) and (pkt[19:21] == b"\xaa\xfe")) or \
((self.mode & ScannerMode.MODE_ESTIMOTE) and (pkt[19:21] == b"\x9a\xfe"))):
return
bt_addr = bt_addr_to_string(pkt[7:13])
rssi = bin_to_int(pkt[-1])
# strip bluetooth address and parse packet
packet = parse_packet(pkt[14:-1])
# return if packet was not an beacon advertisement
if not packet:
return
# we need to remeber which eddystone beacon has which bt address
# because the TLM and URL frames do not contain the namespace and instance
self.save_bt_addr(packet, bt_addr)
# properties holds the identifying information for a beacon
# e.g. instance and namespace for eddystone; uuid, major, minor for iBeacon
properties = self.get_properties(packet, bt_addr)
if self.device_filter is None and self.packet_filter is None:
# no filters selected
self.callback(bt_addr, rssi, packet, properties)
elif self.device_filter is None:
# filter by packet type
if is_one_of(packet, self.packet_filter):
self.callback(bt_addr, rssi, packet, properties)
else:
# filter by device and packet type
if self.packet_filter and not is_one_of(packet, self.packet_filter):
# return if packet filter does not match
return
# iterate over filters and call .matches() on each
for filtr in self.device_filter:
if isinstance(filtr, BtAddrFilter):
if filtr.matches({'bt_addr':bt_addr}):
self.callback(bt_addr, rssi, packet, properties)
return
elif filtr.matches(properties):
self.callback(bt_addr, rssi, packet, properties)
return | python | def process_packet(self, pkt):
"""Parse the packet and call callback if one of the filters matches."""
# check if this could be a valid packet before parsing
# this reduces the CPU load significantly
if not ( \
((self.mode & ScannerMode.MODE_IBEACON) and (pkt[19:23] == b"\x4c\x00\x02\x15")) or \
((self.mode & ScannerMode.MODE_EDDYSTONE) and (pkt[19:21] == b"\xaa\xfe")) or \
((self.mode & ScannerMode.MODE_ESTIMOTE) and (pkt[19:21] == b"\x9a\xfe"))):
return
bt_addr = bt_addr_to_string(pkt[7:13])
rssi = bin_to_int(pkt[-1])
# strip bluetooth address and parse packet
packet = parse_packet(pkt[14:-1])
# return if packet was not an beacon advertisement
if not packet:
return
# we need to remeber which eddystone beacon has which bt address
# because the TLM and URL frames do not contain the namespace and instance
self.save_bt_addr(packet, bt_addr)
# properties holds the identifying information for a beacon
# e.g. instance and namespace for eddystone; uuid, major, minor for iBeacon
properties = self.get_properties(packet, bt_addr)
if self.device_filter is None and self.packet_filter is None:
# no filters selected
self.callback(bt_addr, rssi, packet, properties)
elif self.device_filter is None:
# filter by packet type
if is_one_of(packet, self.packet_filter):
self.callback(bt_addr, rssi, packet, properties)
else:
# filter by device and packet type
if self.packet_filter and not is_one_of(packet, self.packet_filter):
# return if packet filter does not match
return
# iterate over filters and call .matches() on each
for filtr in self.device_filter:
if isinstance(filtr, BtAddrFilter):
if filtr.matches({'bt_addr':bt_addr}):
self.callback(bt_addr, rssi, packet, properties)
return
elif filtr.matches(properties):
self.callback(bt_addr, rssi, packet, properties)
return | [
"def",
"process_packet",
"(",
"self",
",",
"pkt",
")",
":",
"if",
"not",
"(",
"(",
"(",
"self",
".",
"mode",
"&",
"ScannerMode",
".",
"MODE_IBEACON",
")",
"and",
"(",
"pkt",
"[",
"19",
":",
"23",
"]",
"==",
"b\"\\x4c\\x00\\x02\\x15\"",
")",
")",
"or"... | Parse the packet and call callback if one of the filters matches. | [
"Parse",
"the",
"packet",
"and",
"call",
"callback",
"if",
"one",
"of",
"the",
"filters",
"matches",
"."
] | 15a83e9750d0a4393f8a36868e07f6d9458253fe | https://github.com/citruz/beacontools/blob/15a83e9750d0a4393f8a36868e07f6d9458253fe/beacontools/scanner.py#L163-L213 | train |
citruz/beacontools | beacontools/scanner.py | Monitor.save_bt_addr | def save_bt_addr(self, packet, bt_addr):
"""Add to the list of mappings."""
if isinstance(packet, EddystoneUIDFrame):
# remove out old mapping
new_mappings = [m for m in self.eddystone_mappings if m[0] != bt_addr]
new_mappings.append((bt_addr, packet.properties))
self.eddystone_mappings = new_mappings | python | def save_bt_addr(self, packet, bt_addr):
"""Add to the list of mappings."""
if isinstance(packet, EddystoneUIDFrame):
# remove out old mapping
new_mappings = [m for m in self.eddystone_mappings if m[0] != bt_addr]
new_mappings.append((bt_addr, packet.properties))
self.eddystone_mappings = new_mappings | [
"def",
"save_bt_addr",
"(",
"self",
",",
"packet",
",",
"bt_addr",
")",
":",
"if",
"isinstance",
"(",
"packet",
",",
"EddystoneUIDFrame",
")",
":",
"new_mappings",
"=",
"[",
"m",
"for",
"m",
"in",
"self",
".",
"eddystone_mappings",
"if",
"m",
"[",
"0",
... | Add to the list of mappings. | [
"Add",
"to",
"the",
"list",
"of",
"mappings",
"."
] | 15a83e9750d0a4393f8a36868e07f6d9458253fe | https://github.com/citruz/beacontools/blob/15a83e9750d0a4393f8a36868e07f6d9458253fe/beacontools/scanner.py#L215-L221 | train |
citruz/beacontools | beacontools/scanner.py | Monitor.get_properties | def get_properties(self, packet, bt_addr):
"""Get properties of beacon depending on type."""
if is_one_of(packet, [EddystoneTLMFrame, EddystoneURLFrame, \
EddystoneEncryptedTLMFrame, EddystoneEIDFrame]):
# here we retrieve the namespace and instance which corresponds to the
# eddystone beacon with this bt address
return self.properties_from_mapping(bt_addr)
else:
return packet.properties | python | def get_properties(self, packet, bt_addr):
"""Get properties of beacon depending on type."""
if is_one_of(packet, [EddystoneTLMFrame, EddystoneURLFrame, \
EddystoneEncryptedTLMFrame, EddystoneEIDFrame]):
# here we retrieve the namespace and instance which corresponds to the
# eddystone beacon with this bt address
return self.properties_from_mapping(bt_addr)
else:
return packet.properties | [
"def",
"get_properties",
"(",
"self",
",",
"packet",
",",
"bt_addr",
")",
":",
"if",
"is_one_of",
"(",
"packet",
",",
"[",
"EddystoneTLMFrame",
",",
"EddystoneURLFrame",
",",
"EddystoneEncryptedTLMFrame",
",",
"EddystoneEIDFrame",
"]",
")",
":",
"return",
"self"... | Get properties of beacon depending on type. | [
"Get",
"properties",
"of",
"beacon",
"depending",
"on",
"type",
"."
] | 15a83e9750d0a4393f8a36868e07f6d9458253fe | https://github.com/citruz/beacontools/blob/15a83e9750d0a4393f8a36868e07f6d9458253fe/beacontools/scanner.py#L223-L231 | train |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.