code string | signature string | docstring string | loss_without_docstring float64 | loss_with_docstring float64 | factor float64 |
|---|---|---|---|---|---|
points = self._read_from_sql("SELECT * FROM history;", db_name)
return list(points.columns.values)[1:] | def points_from_sql(self, db_name) | Retrieve point list from SQL database | 8.967523 | 8.163185 | 1.098532 |
his = self._read_from_sql('select * from "%s"' % "history", db_name)
his.index = his["index"].apply(Timestamp)
return his.set_index("index")[point] | def his_from_sql(self, db_name, point) | Retrive point histories from SQL database | 7.180213 | 6.713727 | 1.069482 |
with open("%s.bin" % device_name, "rb") as file:
return pickle.load(file)["points"][point] | def read_point_prop(self, device_name, point) | Points properties retrieved from pickle | 5.477357 | 4.757221 | 1.151378 |
with open("{}.bin".format(device_name), "rb") as file:
return pickle.load(file)["device"] | def read_dev_prop(self, device_name) | Device properties retrieved from pickle | 6.335277 | 4.922899 | 1.2869 |
try:
res = self.properties.device.properties.network.read(
"{} {} {} presentValue".format(
self.properties.device.properties.address,
self.properties.type,
str(self.properties.address),
)
... | def value(self) | Read the value from BACnet network | 7.018139 | 6.367179 | 1.102237 |
if self.lastValue == 1 or self.lastValue == "active":
self._key = 1
self._boolKey = True
else:
self._key = 0
self._boolKey = False
return self._boolKey | def boolValue(self) | returns : (boolean) Value | 4.807156 | 4.578217 | 1.050006 |
try:
return self.properties.units_state[int(self.lastValue) - 1]
except IndexError:
value = "unknown"
except ValueError:
value = "NaN"
return value | def enumValue(self) | returns: (str) Enum state value | 8.36361 | 8.415505 | 0.993833 |
try:
value = self.lastValue
except IndexError:
value = "NaN"
except ValueError:
value = "NaN"
return value | def value(self) | Take last known value as the value | 6.260675 | 4.689091 | 1.335158 |
def _batches(self, request, points_per_request):
for i in range(0, len(request), points_per_request):
yield request[i : i + points_per_request] | Generator for creating 'request batches'. Each batch contains a maximum of "points_per_request"
points to read.
:params: request a list of point_name as a list
:params: (int) points_per_request
:returns: (iter) list of point_name of size <= points_per_request | null | null | null | |
def _rpm_request_by_name(self, point_list):
points = []
requests = []
for each in point_list:
str_list = []
point = self._findPoint(each, force_read=False)
points.append(point)
str_list.append(" " + point.properties.type)
... | :param point_list: a list of point
:returns: (tuple) read request for each points, points | null | null | null | |
def read_multiple(
self,
points_list,
*,
points_per_request=25,
discover_request=(None, 6),
force_single=False
):
if not self.properties.pss["readPropertyMultiple"] or force_single:
self._log.warning("Read property Multiple Not s... | Read points from a device using a ReadPropertyMultiple request.
[ReadProperty requests are very slow in comparison].
:param points_list: (list) a list of all point_name as str
:param points_per_request: (int) number of points in the request
Requesting many points results big requ... | null | null | null | |
def read_multiple(
self, points_list, *, points_per_request=1, discover_request=(None, 6)
):
# print('PSS : %s' % self.properties.pss['readPropertyMultiple'])
if isinstance(points_list, list):
for each in points_list:
self.read_single(
... | Functions to read points from a device using the ReadPropertyMultiple request.
Using readProperty request can be very slow to read a lot of data.
:param points_list: (list) a list of all point_name as str
:param points_per_request: (int) number of points in the request
Using too ... | null | null | null | |
def poll(self, command="start", *, delay=120):
if delay > 120:
self._log.warning(
"Segmentation not supported, forcing delay to 120 seconds (or higher)"
)
delay = 120
# for each in self.points:
# each.value
# self._... | Poll a point every x seconds (delay=x sec)
Can be stopped by using point.poll('stop') or .poll(0) or .poll(False)
or by setting a delay = 0
:param command: (str) start or stop polling
:param delay: (int) time delay between polls in seconds
:type command: str
:type... | null | null | null | |
statistics = {}
mstp_networks = []
mstp_map = {}
ip_devices = []
bacoids = []
mstp_devices = []
for address, bacoid in self.whois_answer[0].keys():
if ":" in address:
net, mac = address.split(":")
mstp_networks.... | def network_stats(self) | Used by Flask to show informations on the network | 3.067455 | 3.055669 | 1.003857 |
def connect(self, *, db=None):
if db:
self.poll(command="stop")
self.properties.db_name = db.split(".")[0]
self.new_state(DeviceFromDB)
else:
self._log.warning(
"Already connected, provide db arg if you want to connect to d... | A connected device can be switched to 'database mode' where the device will
not use the BACnet network but instead obtain its contents from a previously
stored database. | null | null | null | |
def df(self, list_of_points, force_read=True):
his = []
for point in list_of_points:
try:
his.append(self._findPoint(point, force_read=force_read).history)
except ValueError as ve:
self._log.error("{}".format(ve))
... | When connected, calling DF should force a reading on the network. | null | null | null | |
def _buildPointList(self):
try:
self.properties.pss.value = self.properties.network.read(
"{} device {} protocolServicesSupported".format(
self.properties.address, self.properties.device_id
)
)
except NoRespon... | Upon connection to build the device point list and properties. | null | null | null | |
def analog_units(self):
au = []
us = []
for each in self.points:
if isinstance(each, NumericPoint):
au.append(each.properties.name)
us.append(each.properties.units_state)
return dict(zip(au, us)) | Shortcut to retrieve all analog points units [Used by Bokeh trending feature] | null | null | null | |
def _findPoint(self, name, force_read=True):
for point in self.points:
if point.properties.name == name:
if force_read:
point.value
return point
raise ValueError("{} doesn't exist in controller".format(name)) | Used by getter and setter functions | null | null | null | |
def connect(self, *, db=None):
if not self.properties.network:
self.new_state(DeviceFromDB)
else:
try:
name = self.properties.network.read(
"{} device {} objectName".format(
self.properties.address, self... | Attempt to connect to device. If unable, attempt to connect to a controller database
(so the user can use previously saved data). | null | null | null | |
def connect(self, *, network=None, from_backup=None):
if network and from_backup:
raise WrongParameter("Please provide network OR from_backup")
elif network:
self.properties.network = network
try:
name = self.properties.network.read(
... | In DBState, a device can be reconnected to BACnet using:
device.connect(network=bacnet) (bacnet = BAC0.connect()) | null | null | null | |
if level:
file = level
stderr = level
stdout = level
file = convert_level(file)
stderr = convert_level(stderr)
stdout = convert_level(stdout)
BAC0_logger = logging.getLogger("BAC0")
# if console:
# BAC0_logger.setLevel(console)
# BAC0_logger.... | def update_log_level(level=None, *, file=None, stderr=None, stdout=None) | Typical usage :
Normal
BAC0.log_level(file='warning', stdout='warning', stderr='error')
Info on console....but not in file
BAC0.log_level(file='warning', stdout='info', stderr='error')
Debug
BAC0.log_level(file='debug', stdout='info', stderr='error') | 2.094776 | 1.948343 | 1.075158 |
pss = bacnetapp.read(
"{} device {} protocolServicesSupported".format(address, devID)
)
deviceName = bacnetapp.read("{} device {} objectName".format(address, devID))
# print('Device {}- building points list'.format(deviceName))
objList = bacnetapp.read("{} device {] objectList".format(... | def discoverPoints(bacnetapp, address, devID) | Discover the BACnet points in a BACnet device.
:param bacnetApp: The app itself so we can call read
:param address: address of the device as a string (ex. '2:5')
:param devID: device ID of the bacnet device as a string (ex. '1001')
:returns: a tuple with deviceName, pss, objList, df
* *device... | 2.759398 | 2.463188 | 1.120255 |
if isinstance(previous, CubicBezier):
return (self.start == previous.end and
(self.control1 - self.start) == (previous.end - previous.control2))
else:
return self.control1 == self.start | def is_smooth_from(self, previous) | Checks if this segment would be a smooth segment following the previous | 3.938217 | 3.70458 | 1.063067 |
return ((1 - pos) ** 3 * self.start) + \
(3 * (1 - pos) ** 2 * pos * self.control1) + \
(3 * (1 - pos) * pos ** 2 * self.control2) + \
(pos ** 3 * self.end) | def point(self, pos) | Calculate the x,y position at a certain position of the path | 2.223292 | 2.000332 | 1.111461 |
start_point = self.point(0)
end_point = self.point(1)
return segment_length(self, 0, 1, start_point, end_point, error, min_depth, 0) | def length(self, error=ERROR, min_depth=MIN_DEPTH) | Calculate the length of the path up to a certain position | 3.777231 | 3.382177 | 1.116805 |
if isinstance(previous, QuadraticBezier):
return (self.start == previous.end and
(self.control - self.start) == (previous.end - previous.control))
else:
return self.control == self.start | def is_smooth_from(self, previous) | Checks if this segment would be a smooth segment following the previous | 4.196405 | 3.909942 | 1.073265 |
'''
Registers a blueprint on the WebSockets.
'''
first_registration = False
if blueprint.name in self.blueprints:
assert self.blueprints[blueprint.name] is blueprint, \
'A blueprint\'s name collision occurred between %r and ' \
'%r. Bo... | def register_blueprint(self, blueprint, **options) | Registers a blueprint on the WebSockets. | 3.779158 | 3.211226 | 1.176858 |
line = linecache.getline(filename, lineno)
# Hack warning: might be fooled by comments
rx = re.compile(r'\b%s\b' % re.escape(name) if name != '*' else '[*]')
while line and not rx.search(line):
lineno += 1
line = linecache.getline(filename, lineno)
return lineno | def adjust_lineno(filename, lineno, name) | Adjust the line number of an import.
Needed because import statements can span multiple lines, and our lineno
is always the first line number. | 4.301723 | 4.516315 | 0.952485 |
with open(filename) as f:
root = ast.parse(f.read(), filename)
visitor = ImportFinder(filename)
visitor.visit(root)
return visitor.imports | def find_imports(filename) | Find all imported names in a given file.
Returns a list of ImportInfo objects. | 2.611594 | 3.440902 | 0.758985 |
with open(filename) as f:
root = ast.parse(f.read(), filename)
visitor = ImportFinderAndNameTracker(filename)
visitor.warn_about_duplicates = warn_about_duplicates
visitor.verbose = verbose
visitor.visit(root)
visitor.leaveAllScopes()
return visitor.imports, visitor.unused_names | def find_imports_and_track_names(filename, warn_about_duplicates=False,
verbose=False) | Find all imported names in a given file.
Returns ``(imports, unused)``. Both are lists of ImportInfo objects. | 3.863531 | 4.404156 | 0.877247 |
if os.path.isdir(pathname):
for root, dirs, files in os.walk(pathname):
dirs.sort()
files.sort()
for fn in files:
# ignore emacsish junk
if fn.endswith('.py') and not fn.startswith('.#'):
... | def parsePathname(self, pathname) | Parse one or more source files.
``pathname`` may be a file name or a directory name. | 3.155039 | 3.301712 | 0.955577 |
with open(filename, 'wb') as f:
pickle.dump(self.modules, f) | def writeCache(self, filename) | Write the graph to a cache file. | 3.919198 | 4.366522 | 0.897556 |
with open(filename, 'rb') as f:
self.modules = pickle.load(f) | def readCache(self, filename) | Load the graph from a cache file. | 4.095547 | 4.23454 | 0.967176 |
modname = self.filenameToModname(filename)
module = Module(modname, filename)
self.modules[modname] = module
if self.trackUnusedNames:
module.imported_names, module.unused_names = \
find_imports_and_track_names(filename,
... | def parseFile(self, filename) | Parse a single file. | 4.519828 | 4.439104 | 1.018185 |
for ext in reversed(self._exts):
if filename.endswith(ext):
filename = filename[:-len(ext)]
break
else:
self.warn(filename, '%s: unknown file name extension', filename)
filename = os.path.abspath(filename)
elements = filena... | def filenameToModname(self, filename) | Convert a filename to a module name. | 2.693763 | 2.641886 | 1.019636 |
if dotted_name.endswith('.*'):
return dotted_name[:-2]
name = dotted_name
# extrapath is None only in a couple of test cases; in real life it's
# always present
if level and level > 1 and extrapath:
# strip trailing path bits for each extra level... | def findModuleOfName(self, dotted_name, level, filename, extrapath=None) | Given a fully qualified name, find what module contains it. | 4.368351 | 4.358542 | 1.002251 |
try:
return self._module_cache[(dotted_name, extrapath)]
except KeyError:
pass
if dotted_name in sys.modules or dotted_name in self.builtin_modules:
return dotted_name
filename = dotted_name.replace('.', os.path.sep)
if extrapath:
... | def isModule(self, dotted_name, extrapath=None) | Is ``dotted_name`` the name of a module? | 2.115229 | 2.12556 | 0.99514 |
candidate = self.isModule(dotted_name + '.__init__', extrapath)
if candidate:
candidate = candidate[:-len(".__init__")]
return candidate | def isPackage(self, dotted_name, extrapath=None) | Is ``dotted_name`` the name of a package? | 4.61328 | 4.372097 | 1.055164 |
if '.' not in dotted_name:
return dotted_name
if not self.isPackage(dotted_name):
dotted_name = '.'.join(dotted_name.split('.')[:-1])
if packagelevel:
dotted_name = '.'.join(dotted_name.split('.')[:packagelevel])
return dotted_name | def packageOf(self, dotted_name, packagelevel=None) | Determine the package that contains ``dotted_name``. | 2.084301 | 1.956331 | 1.065413 |
modules = list(self.modules.items())
modules.sort()
return [module for name, module in modules] | def listModules(self) | Return an alphabetical list of all modules. | 4.153345 | 3.37709 | 1.229859 |
packages = {}
for module in self.listModules():
package_name = self.packageOf(module.modname, packagelevel)
if package_name not in packages:
dirname = os.path.dirname(module.filename)
packages[package_name] = Module(package_name, dirname)
... | def packageGraph(self, packagelevel=None) | Convert a module graph to a package graph. | 3.118338 | 2.973269 | 1.048791 |
# This algorithm determines Strongly Connected Components. Look it up.
# It is adapted to suit our data structures.
# Phase 0: prepare the graph
imports = {}
for u in self.modules:
imports[u] = set()
for v in self.modules[u].imports:
... | def collapseCycles(self) | Create a graph with cycles collapsed.
Collapse modules participating in a cycle to a single node. | 2.63132 | 2.568344 | 1.02452 |
for module in self.listModules():
print("%s:" % module.modname)
print(" %s" % "\n ".join(imp.name for imp in module.imported_names)) | def printImportedNames(self) | Produce a report of imported names. | 4.312834 | 3.852823 | 1.119396 |
for module in self.listModules():
print("%s:" % module.label)
if self.external_dependencies:
imports = list(module.imports)
else:
imports = [modname for modname in module.imports
if modname in self.modules]
... | def printImports(self) | Produce a report of dependencies. | 3.93666 | 3.672861 | 1.071824 |
for module in self.listModules():
names = [(unused.lineno, unused.name)
for unused in module.unused_names]
names.sort()
for lineno, name in names:
if not self.all_unused:
line = linecache.getline(module.filenam... | def printUnusedImports(self) | Produce a report of unused imports. | 4.115026 | 3.923336 | 1.048859 |
print("digraph ModuleDependencies {")
print(" node[shape=box];")
allNames = set()
nameDict = {}
for n, module in enumerate(self.listModules()):
module._dot_name = "mod%d" % n
nameDict[module.modname] = module._dot_name
print(" %s[lab... | def printDot(self) | Produce a dependency graph in dot format. | 3.117 | 2.971401 | 1.049 |
text = unicode(text)
return text.translate({
ord('&'): u'&',
ord('<'): u'<',
ord('"'): u'"',
ord('>'): u'>',
ord('@'): u'@',
0xa0: u' '}) | def quote(text) | encode html entities | 2.879999 | 2.536071 | 1.135615 |
"create all classes and put them in ctx"
for (tag, info) in _TAGS.items():
class_name = tag.title()
quote_, compact, self_closing, docs = info
def __init__(self, *childs, **attrs):
TagBase.__init__(self, childs, attrs)
cls = type(class_name, (TagBase,), {
... | def _create_tags(ctx) | create all classes and put them in ctx | 4.952615 | 3.920754 | 1.263179 |
tag = el.tag
namespace = None
if tag.startswith('{'):
# Strip namespace of the form "{namespace}tag"
namespace,tag = tag[1:].split('}')
try:
cls = globals()[tag.title()]
if not issubclass(cls, TagBase):
raise KeyError()
except KeyError:
raise ... | def tag_from_element(el) | Convert an Element into a Tag.
``el`` is an instance of ``Element``. Returns an instance of the
corresponding subclass of ``TagBase``. | 3.085825 | 3.068124 | 1.005769 |
code = ('<div>' + code + '</div>').encode('utf8')
el = ET.fromstring(code)
return [tag_from_element(c) for c in el] | def html_to_tags(code) | Convert HTML code to tags.
``code`` is a string containing HTML code. The return value is a
list of corresponding instances of ``TagBase``. | 4.526862 | 6.421485 | 0.704956 |
fields = self.settings.math_output.split(None, 1)
name = fields[0].lower()
option = fields[1] if len(fields) > 1 else None
if name == 'html':
option = self.settings.math_css or option
self.math_handler = HTMLMathHandler(css_filename=option)
elif n... | def _init_math_handler(self) | Parse math configuration and set up math handler. | 2.906136 | 2.830905 | 1.026575 |
for style in utils.get_stylesheet_list(self.settings):
self.css(style) | def append_default_stylesheets(self) | Appends the default styles defined on the translator settings. | 8.684252 | 6.919717 | 1.255001 |
if self.settings.embed_content:
content = codecs.open(path, 'r', encoding='utf8').read()
tag = Style(content, type="text/css")
else:
tag = Link(href=path, rel="stylesheet", type_="text/css")
self.head.append(tag) | def css(self, path) | Link/embed CSS file. | 4.458042 | 4.138706 | 1.077158 |
res = []
for x in args:
if isinstance(x, tuple) and len(x) == 2:
key, value = x
# todo: exclude this key if value is its default
res += ["%s=%s" % (key, repr_arg(value))]
else:
res += [repr_arg(x)]
return ', '.join(res) | def repr_args(args) | formats a list of function arguments prettily but as working code
(kwargs are tuples (argname, argvalue) | 3.248951 | 3.310125 | 0.981519 |
if isinstance(d, dict):
# if d can be expressed in key=value syntax:
return "{%s}" % ", ".join(
"%s: %s" % (repr_arg(k), repr_arg(v)) for k, v in d.items())
if isinstance(d, list):
return "[%s]" % ", ".join(repr_arg(elem) for elem in d)
if isinstance(d, unicode):
... | def repr_arg(d) | formats a function argument prettily but as working code
unicode encodable as ascii is formatted as str | 2.356075 | 2.351548 | 1.001925 |
res = []
for x in args:
if isinstance(x, tuple) and len(x) == 2:
key, value = x
if value and str_arg(value):
res += ["%s=%s" % (key, str_arg(value))]
else:
res += [str_arg(x)]
return ', '.join(res) | def str_args(args) | formats a list of function arguments prettily not as code
(kwargs are tuples (argname, argvalue) | 2.471332 | 2.497211 | 0.989637 |
if not d:
return None
if isinstance(d, dict):
if len(d) == 2 and d.get('type') == 'text' and 'value' in d:
return str_arg(d['value'])
if len(d) == 2 and d.get('type') == 'text' and 'subkey' in d:
return ".%s" % d['subkey']
if d.get('type') == 'module'... | def str_arg(d) | formats a function argument prettily not as code
dicts are expressed in {key=value} syntax
strings are formatted using str in quotes not repr | 2.257211 | 2.338782 | 0.965123 |
splits = yield asyncGetSplits(_INPUT, conf, **cdicts(opts, kwargs))
parsed = yield asyncDispatch(splits, *get_async_dispatch_funcs())
_OUTPUT = yield asyncStarMap(partial(maybeDeferred, parse_result), parsed)
returnValue(iter(_OUTPUT)) | def asyncPipeHash(context=None, _INPUT=None, conf=None, **kwargs) | A string module that asynchronously hashes the given text. Loopable.
Parameters
----------
context : pipe2py.Context object
_INPUT : twisted Deferred iterable of items or strings
Returns
-------
_OUTPUT : twisted.internet.defer.Deferred generator of hashed strings | 17.021824 | 21.024645 | 0.809613 |
conf = DotDict(conf)
limit = conf.get('count', func=int, **kwargs)
for item in deque(_INPUT, limit):
yield item | def pipe_tail(context=None, _INPUT=None, conf=None, **kwargs) | Returns a specified number of items from the bottom of a feed.
Parameters
----------
context : pipe2py.Context object
_INPUT : pipe2py.modules pipe like object (iterable of items)
kwargs -- terminal, if the truncation value is wired in
conf : count -- length of the truncated feed, if specified ... | 10.178267 | 14.891761 | 0.683483 |
components = map(partial(_visit, graph=graph), graph)
node_component = dict(_gen_node_component(components))
graph_component = {component: [] for component in components}
graph_component.update(
dict(_gen_graph_component(graph, node_component, _gen_graph_value)))
return graph_component | def get_graph_component(graph) | Identify strongly connected components in a graph using
Tarjan's algorithm.
graph should be a dictionary mapping node names to
lists of successor nodes. | 5.690787 | 6.458934 | 0.881072 |
splits = yield asyncGetSplits(_INPUT, conf['RULE'], **cdicts(opts, kwargs))
first = partial(maybeDeferred, convert_func)
asyncFuncs = get_async_dispatch_funcs(first=first)
parsed = yield asyncDispatch(splits, *asyncFuncs)
_OUTPUT = yield asyncStarMap(asyncParseResult, parsed)
returnValue(it... | def asyncPipeStrregex(context=None, _INPUT=None, conf=None, **kwargs) | A string module that asynchronously replaces text using regexes. Each
has the general format: "In [field] replace [regex pattern] with [text]".
Loopable.
Parameters
----------
context : pipe2py.Context object
_INPUT : twisted Deferred iterable of items or strings
conf : {
'RULE': [
... | 20.139305 | 21.520439 | 0.935822 |
splits = get_splits(_INPUT, conf['RULE'], **cdicts(opts, kwargs))
parsed = utils.dispatch(splits, *get_dispatch_funcs(first=convert_func))
_OUTPUT = starmap(parse_result, parsed)
return _OUTPUT | def pipe_strregex(context=None, _INPUT=None, conf=None, **kwargs) | A string module that replaces text using regexes. Each has the general
format: "In [field] replace [regex pattern] with [text]". Loopable.
Parameters
----------
context : pipe2py.Context object
_INPUT : iterable of items or strings
conf : {
'RULE': [
{
'match... | 22.527275 | 20.217358 | 1.114254 |
conf = DotDict(conf)
urls = utils.listize(conf['URL'])
for item in _INPUT:
for item_url in urls:
url = utils.get_value(DotDict(item_url), DotDict(item), **kwargs)
url = utils.get_abspath(url)
f = urlopen(url)
# TODO: it seems that Yahoo! convert... | def pipe_xpathfetchpage(context=None, _INPUT=None, conf=None, **kwargs) | A source that fetches the content of a given website as DOM nodes or a
string. Loopable.
context : pipe2py.Context object
_INPUT : pipeforever pipe or an iterable of items or fields
conf : dict
URL -- url object contain the URL to download
xpath -- xpath to extract
html5 -- use htm... | 6.465731 | 5.897513 | 1.096349 |
if pipe_def:
pydeps = gen_dependencies(pipe_def)
elif pipe_generator:
pydeps = pipe_generator(Context(describe_dependencies=True))
else:
raise Exception('Must supply at least one kwarg!')
return sorted(set(pydeps)) | def extract_dependencies(pipe_def=None, pipe_generator=None) | Extract modules used by a pipe | 5.978137 | 5.959578 | 1.003114 |
if pipe_def:
pyinput = gen_input(pipe_def)
elif pipe_generator:
pyinput = pipe_generator(Context(describe_input=True))
else:
raise Exception('Must supply at least one kwarg!')
return sorted(list(pyinput)) | def extract_input(pipe_def=None, pipe_generator=None) | Extract inputs required by a pipe | 6.692542 | 6.704779 | 0.998175 |
replace = {'-': '_', ':': '_', '/': '_'}
func = lambda id, pair: id.replace(pair[0], pair[1])
id = reduce(func, replace.iteritems(), id)
id = '_%s' % id if id[0] in string.digits else id
return id.encode(encoding) | def pythonise(id, encoding='ascii') | Return a Python-friendly id | 3.810938 | 3.589513 | 1.061687 |
i = dict(element.items())
content = element.text.strip() if element.text else None
i.update({'content': content}) if content else None
if len(element.getchildren()):
for child in element.iterchildren():
tag = child.tag.split('}', 1)[-1]
new = etree_to_dict(child)
... | def etree_to_dict(element) | Convert an eTree xml into dict imitating how Yahoo Pipes does it.
todo: further investigate white space and multivalue handling | 3.033886 | 3.151212 | 0.962768 |
map_func = kwargs.get('map_func', _map_func)
apply_func = kwargs.get('apply_func', _apply_func)
splits = izip(*tee(_INPUT, len(funcs)))
return map_func(partial(apply_func, funcs), splits) | def broadcast(_INPUT, *funcs, **kwargs) | copies an iterable and delivers the items to multiple functions
/--> foo2bar(_INPUT) --> \
/ \
_INPUT ---> foo2baz(_INPUT) ---> _OUTPUT
\ /
\--> foo2qux(_INPUT) --> /
One way to construct such a flow in code would be::... | 4.056331 | 4.529867 | 0.895464 |
map_func = kwargs.get('map_func', _map_func)
apply_func = kwargs.get('apply_func', _apply_func)
return map_func(partial(apply_func, funcs), splits) | def dispatch(splits, *funcs, **kwargs) | takes multiple iterables (returned by dispatch or broadcast) and delivers
the items to multiple functions
/-----> _INPUT1 --> double(_INPUT1) --> \
/ \
splits ------> _INPUT2 --> triple(_INPUT2) ---> _OUTPUT
\ ... | 3.228768 | 4.499147 | 0.71764 |
name = conf['name']['value']
prompt = conf['prompt']['value']
default = conf['default']['value'] or conf['debug']['value']
if context.submodule or context.inputs:
value = context.inputs.get(name, default)
elif not context.test:
# we skip user interaction during tests
ra... | def get_input(context, conf) | Gets a user parameter, either from the console or from an outer
submodule/system
Assumes conf has name, default, prompt and debug | 5.200179 | 4.720092 | 1.101711 |
try:
return quote(url, safe=URL_SAFE)
except KeyError:
return quote(encode(url), safe=URL_SAFE) | def url_quote(url) | Ensure url is valid | 3.387927 | 3.499895 | 0.968008 |
flags = rules[0]['flags']
# Create a combined regex from the rules
tuples = ((p, r['match']) for p, r in enumerate(rules))
regexes = ('(?P<match_%i>%s)' % (p, r) for p, r in tuples)
pattern = '|'.join(regexes)
regex = re.compile(pattern, flags)
resplit = re.compile('\$(\d+)')
# Fo... | def multi_substitute(word, rules) | Apply multiple regex rules to 'word'
http://code.activestate.com/recipes/
576710-multi-regex-single-pass-replace-of-multiple-regexe/ | 3.744881 | 3.719945 | 1.006703 |
pkwargs = cdicts(opts, kwargs)
asyncFuncs = yield asyncGetSplits(None, conf['attrs'], **pkwargs)
_input = yield _INPUT
finite = utils.finitize(_input)
inputs = imap(DotDict, finite)
pieces = yield asyncImap(asyncFuncs[0], inputs)
results = imap(utils.parse_params, pieces)
_OUTPUT = ... | def asyncPipeItembuilder(context=None, _INPUT=None, conf=None, **kwargs) | A source that asynchronously builds an item. Loopable.
Parameters
----------
context : pipe2py.Context object
_INPUT : asyncPipe like object (twisted Deferred iterable of items)
conf : {
'attrs': [
{'key': {'value': 'title'}, 'value': {'value': 'new title'}},
{'key':... | 12.827152 | 14.517302 | 0.883577 |
funcs = get_splits(None, conf['attrs'], **cdicts(opts, kwargs))
finite = utils.finitize(_INPUT)
inputs = imap(DotDict, finite)
pieces = imap(funcs[0], inputs)
results = imap(utils.parse_params, pieces)
_OUTPUT = imap(DotDict, results)
return _OUTPUT | def pipe_itembuilder(context=None, _INPUT=None, conf=None, **kwargs) | A source that builds an item. Loopable.
Parameters
----------
context : pipe2py.Context object
_INPUT : pipeforever pipe or an iterable of items
conf : {
'attrs': [
{'key': {'value': <'title'>}, 'value': {'value': <'chair'>}},
{'key': {'value': <'color'>}, 'value': {... | 12.478252 | 13.485258 | 0.925325 |
cust_func = get_cust_func(context, conf, embed, parse_embed, **kwargs)
opts.update({'cust_func': cust_func})
splits = yield asyncGetSplits(_INPUT, conf, **cdicts(opts, kwargs))
gathered = yield asyncStarMap(asyncParseResult, splits)
_OUTPUT = utils.multiplex(gathered)
returnValue(_OUTPUT) | def asyncPipeLoop(context=None, _INPUT=None, conf=None, embed=None, **kwargs) | An operator that asynchronously loops over the input and performs the
embedded submodule. Not loopable.
Parameters
----------
context : pipe2py.Context object
_INPUT : asyncPipe like object (twisted Deferred iterable of items)
embed : the submodule, i.e., asyncPipe*(context, _INPUT, conf)
... | 10.588764 | 12.814588 | 0.826305 |
cust_func = get_cust_func(context, conf, embed, parse_embed, **kwargs)
opts.update({'cust_func': cust_func})
splits = get_splits(_INPUT, conf, **cdicts(opts, kwargs))
gathered = starmap(parse_result, splits)
_OUTPUT = utils.multiplex(gathered)
return _OUTPUT | def pipe_loop(context=None, _INPUT=None, conf=None, embed=None, **kwargs) | An operator that loops over the input and performs the embedded
submodule. Not loopable.
Parameters
----------
context : pipe2py.Context object
_INPUT : pipe2py.modules pipe like object (iterable of items)
embed : the submodule, i.e., pipe_*(context, _INPUT, conf)
Most modules, with the... | 9.072318 | 10.854362 | 0.835822 |
conf = DotDict(conf)
split_token = conf.get('token', **kwargs)
urls = utils.listize(conf['URL'])
for item in _INPUT:
for item_url in urls:
url = utils.get_value(DotDict(item_url), DotDict(item), **kwargs)
url = utils.get_abspath(url)
if not url:
... | def pipe_fetchpage(context=None, _INPUT=None, conf=None, **kwargs) | A source that fetches the content of a given web site as a string.
Loopable.
context : pipe2py.Context object
_INPUT : pipeforever asyncPipe or an iterable of items or fields
conf : dict
URL -- url object contain the URL to download
from -- string from where to start the input
to ... | 7.938751 | 7.449667 | 1.065652 |
# todo: iCal and KML
funcs = get_splits(None, conf, **cdicts(opts, kwargs))
parsed = get_parsed(_INPUT, funcs[0])
results = starmap(parse_result, parsed)
items = imap(utils.gen_items, results)
_OUTPUT = utils.multiplex(items)
return _OUTPUT | def pipe_fetchdata(context=None, _INPUT=None, conf=None, **kwargs) | A source that fetches and parses an XML or JSON file. Loopable.
Parameters
----------
context : pipe2py.Context object
_INPUT : pipeforever pipe or an iterable of items or fields
conf : {
'URL': {'value': <url>},
'path': {'value': <dot separated path to data list>}
}
Yields... | 16.847126 | 20.146149 | 0.836245 |
splits = yield asyncGetSplits(_INPUT, conf['URL'], **cdicts(opts, kwargs))
items = yield asyncStarMap(asyncParseResult, splits)
_OUTPUT = utils.multiplex(items)
returnValue(_OUTPUT) | def asyncPipeFetch(context=None, _INPUT=None, conf=None, **kwargs) | A source that asynchronously fetches and parses one or more feeds to
return the feed entries. Loopable.
Parameters
----------
context : pipe2py.Context object
_INPUT : asyncPipe like object (twisted Deferred iterable of items)
conf : {
'URL': [
{'type': 'url', 'value': <url1... | 18.30233 | 19.91452 | 0.919044 |
splits = get_splits(_INPUT, conf['URL'], **cdicts(opts, kwargs))
items = starmap(parse_result, splits)
_OUTPUT = utils.multiplex(items)
return _OUTPUT | def pipe_fetch(context=None, _INPUT=None, conf=None, **kwargs) | A source that fetches and parses one or more feeds to return the
entries. Loopable.
Parameters
----------
context : pipe2py.Context object
_INPUT : pipeforever pipe or an iterable of items or fields
conf : {
'URL': [
{'type': 'url', 'value': <url1>},
{'type': 'ur... | 18.19445 | 16.804356 | 1.082722 |
conf = DotDict(conf)
test = kwargs.pop('pass_if', None)
permit = conf.get('MODE', **kwargs) == 'permit'
combine = conf.get('COMBINE', **kwargs)
if not combine in {'and', 'or'}:
raise Exception(
"Invalid combine: %s. (Expected 'and' or 'or')" % combine)
rule_defs = map(... | def pipe_filter(context=None, _INPUT=None, conf=None, **kwargs) | An operator that filters for source items matching the given rules.
Not loopable.
Parameters
----------
context : pipe2py.Context object
_INPUT : pipe2py.modules pipe like object (iterable of items)
conf : {
'MODE': {'value': <'permit' or 'block'>},
'COMBINE': {'value': <'and' o... | 5.733296 | 5.896853 | 0.972264 |
return Split(context, _INPUT, conf, splits, **kwargs) | def pipe_split(context, _INPUT, conf, splits, **kwargs) | An operator that splits a source into identical copies. Not loopable.
Parameters
----------
context : pipe2py.Context object
_INPUT : pipe2py.modules pipe like object (iterable of items)
conf : dict
splits : number of copies
Yields
------
_OUTPUT, _OUTPUT2... : copies of all source... | 5.024946 | 12.37373 | 0.406098 |
conf = DotDict(conf)
for item in _INPUT:
_input = DotDict(item)
date = utils.get_value(conf['DATE'], _input, **kwargs).lower()
if date.endswith(' day') or date.endswith(' days'):
count = int(date.split(' ')[0])
new_date = dt.today() + timedelta(days=count)
... | def pipe_datebuilder(context=None, _INPUT=None, conf=None, **kwargs) | A date module that converts a text string into a datetime value. Useful
as terminal data. Loopable.
Parameters
----------
context : pipe2py.Context object
_INPUT : pipeforever pipe or an iterable of items
conf : {'DATE': {'type': 'datetime', 'value': '12/2/2014'}}
Yields
------
_OU... | 2.922286 | 3.117914 | 0.937257 |
deferreds = imap(asyncCallable, *iterables)
return gatherResults(deferreds, consumeErrors=True) | def asyncImap(asyncCallable, *iterables) | itertools.imap for deferred callables | 5.704492 | 5.026701 | 1.134838 |
results = []
yield coopStar(asyncCallable, results.append, iterable)
returnValue(results) | def asyncStarCmap(asyncCallable, iterable) | itertools.starmap for deferred callables using cooperative multitasking | 19.049925 | 16.660751 | 1.143401 |
results = []
yield asyncStarParallel(asyncCallable, results.append, iterable)
returnValue(results) | def asyncStarPmap(asyncCallable, iterable) | itertools.starmap for deferred callables using parallel cooperative
multitasking | 13.569991 | 16.474888 | 0.823677 |
deferreds = starmap(asyncCallable, iterable)
return gatherResults(deferreds, consumeErrors=True) | def asyncStarMap(asyncCallable, iterable) | itertools.starmap for deferred callables | 6.666833 | 5.858942 | 1.13789 |
get_value = partial(utils.get_value, **kwargs)
pkwargs = utils.combine_dicts({'parse_func': get_value}, kwargs)
parse_conf = partial(utils.parse_conf, DotDict(conf), **pkwargs)
get_RSS = lambda key, value: (RSS.get(key, key), value)
get_YAHOO = lambda key, value: (YAHOO.get(key), value)
mak... | def pipe_rssitembuilder(context=None, _INPUT=None, conf=None, **kwargs) | A source that builds an rss item. Loopable.
Parameters
----------
context : pipe2py.Context object
_INPUT : pipeforever asyncPipe or an iterable of items or fields
conf : {
'mediaContentType': {'type': 'text', 'value': ''},
'mediaContentHeight': {'type': 'text', 'value': ''},
... | 4.842864 | 5.310192 | 0.911994 |
splits = yield asyncGetSplits(_INPUT, conf['part'], **cdicts(opts, kwargs))
_OUTPUT = yield asyncStarMap(partial(maybeDeferred, parse_result), splits)
returnValue(iter(_OUTPUT)) | def asyncPipeStrconcat(context=None, _INPUT=None, conf=None, **kwargs) | A string module that asynchronously builds a string. Loopable. No direct
input.
Parameters
----------
context : pipe2py.Context object
_INPUT : asyncPipe like object (twisted Deferred iterable of items)
conf : {
'part': [
{'value': <'<img src="'>},
{'subkey': <'i... | 24.255583 | 28.286255 | 0.857504 |
splits = get_splits(_INPUT, conf['part'], **cdicts(opts, kwargs))
_OUTPUT = starmap(parse_result, splits)
return _OUTPUT | def pipe_strconcat(context=None, _INPUT=None, conf=None, **kwargs) | A string module that builds a string. Loopable.
Parameters
----------
context : pipe2py.Context object
_INPUT : pipeforever pipe or an iterable of items
conf : {
'part': [
{'value': '<img src="'},
{'subkey': 'img.src'},
{'value': '">'}
]
}
... | 23.076048 | 18.777336 | 1.228931 |
_input = yield _INPUT
asyncFuncs = yield asyncGetSplits(None, conf, **cdicts(opts, kwargs))
pieces = yield asyncFuncs[0]()
_pass = yield asyncFuncs[2]()
_OUTPUT = _input if _pass else unique_items(_input, pieces.field)
returnValue(_OUTPUT) | def asyncPipeUniq(context=None, _INPUT=None, conf=None, **kwargs) | An operator that asynchronously filters out non unique items according
to the specified field. Not loopable.
Parameters
----------
context : pipe2py.Context object
_INPUT : twisted Deferred iterable of items
conf : {'field': {'type': 'text', 'value': <field to be unique>}}
returns
----... | 19.806488 | 19.451721 | 1.018238 |
funcs = get_splits(None, conf, **cdicts(opts, kwargs))
pieces, _pass = funcs[0](), funcs[2]()
_OUTPUT = _INPUT if _pass else unique_items(_INPUT, pieces.field)
return _OUTPUT | def pipe_uniq(context=None, _INPUT=None, conf=None, **kwargs) | An operator that filters out non unique items according to the specified
field. Not loopable.
Parameters
----------
context : pipe2py.Context object
_INPUT : pipe2py.modules pipe like object (iterable of items)
kwargs -- other inputs, e.g. to feed terminals for rule values
conf : {'field': ... | 19.378986 | 20.162096 | 0.961159 |
_input = yield _INPUT
_OUTPUT = get_output(_input, **kwargs)
returnValue(_OUTPUT) | def asyncPipeUnion(context=None, _INPUT=None, conf=None, **kwargs) | An operator that asynchronously merges multiple source together.
Not loopable.
Parameters
----------
context : pipe2py.Context object
_INPUT : asyncPipe like object (twisted Deferred iterable of items)
conf : unused
Keyword arguments
-----------------
_OTHER1 : asyncPipe like objec... | 12.108624 | 15.705399 | 0.770985 |
_OUTPUT = get_output(_INPUT, **kwargs)
return _OUTPUT | def pipe_union(context=None, _INPUT=None, conf=None, **kwargs) | An operator that merges multiple source together. Not loopable.
Parameters
----------
context : pipe2py.Context object
_INPUT : pipe2py.modules pipe like object (iterable of items)
conf : unused
Keyword arguments
-----------------
_OTHER1 : pipe2py.modules pipe like object
_OTHER2... | 7.689914 | 14.03522 | 0.547901 |
test = kwargs.pop('pass_if', None)
_pass = utils.get_pass(test=test)
key_defs = imap(DotDict, utils.listize(conf['KEY']))
get_value = partial(utils.get_value, **kwargs)
parse_conf = partial(utils.parse_conf, parse_func=get_value, **kwargs)
keys = imap(parse_conf, key_defs)
order = ('%s%... | def pipe_sort(context=None, _INPUT=None, conf=None, **kwargs) | An operator that sorts the input source according to the specified key.
Not loopable. Not lazy.
Parameters
----------
context : pipe2py.Context object
_INPUT : pipe2py.modules pipe like object (iterable of items)
kwargs -- other inputs, e.g. to feed terminals for rule values
conf : {
... | 5.176033 | 4.830243 | 1.071588 |
conf = DotDict(conf)
for item in _INPUT:
item = DotDict(item)
yield {
value: item.get(conf.get(key, **kwargs))
for key, value in RSS_FIELDS.items()} | def pipe_createrss(context=None, _INPUT=None, conf=None, **kwargs) | An operator that converts a source into an RSS stream. Not loopable. | 7.411638 | 7.133359 | 1.039011 |
conf = DotDict(conf)
urls = utils.listize(conf['URL'])
for item in _INPUT:
for item_url in urls:
url = utils.get_value(DotDict(item_url), DotDict(item), **kwargs)
url = utils.get_abspath(url)
if context and context.verbose:
print "pipe_fetch... | def pipe_fetchsitefeed(context=None, _INPUT=None, conf=None, **kwargs) | A source that fetches and parses the first feed found on one or more
sites. Loopable.
Parameters
----------
context : pipe2py.Context object
_INPUT : pipeforever pipe or an iterable of items or fields
conf : URL -- url
Yields
------
_OUTPUT : items | 9.712928 | 9.708862 | 1.000419 |
splits = yield asyncGetSplits(_INPUT, conf['RULE'], **cdicts(opts, kwargs))
asyncConvert = partial(maybeDeferred, convert_func)
asyncFuncs = get_async_dispatch_funcs('pass', asyncConvert)
parsed = yield asyncDispatch(splits, *asyncFuncs)
_OUTPUT = yield maybeDeferred(parse_results, parsed)
... | def asyncPipeRegex(context=None, _INPUT=None, conf=None, **kwargs) | An operator that asynchronously replaces text in items using regexes.
Each has the general format: "In [field] replace [match] with [replace]".
Not loopable.
Parameters
----------
context : pipe2py.Context object
_INPUT : asyncPipe like object (twisted Deferred iterable of items)
conf : {
... | 16.606449 | 17.323242 | 0.958622 |
splits = get_splits(_INPUT, conf['RULE'], **cdicts(opts, kwargs))
parsed = utils.dispatch(splits, *get_dispatch_funcs('pass', convert_func))
_OUTPUT = parse_results(parsed)
return _OUTPUT | def pipe_regex(context=None, _INPUT=None, conf=None, **kwargs) | An operator that replaces text in items using regexes. Each has the
general format: "In [field] replace [match] with [replace]". Not loopable.
Parameters
----------
context : pipe2py.Context object
_INPUT : pipe2py.modules pipe like object (iterable of items)
conf : {
'RULE': [
... | 20.777119 | 19.820429 | 1.048268 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.