code string | signature string | docstring string | loss_without_docstring float64 | loss_with_docstring float64 | factor float64 |
|---|---|---|---|---|---|
self.__prepare()
total = 0
for i in self._json_data:
total += i.get(property)
return total | def sum(self, property) | Getting the sum according to the given property
:@param property
:@type property: string
:@return int/float | 6.606742 | 6.706946 | 0.98506 |
self.__prepare()
try:
return max(self._json_data, key=lambda x: x[property]).get(property)
except KeyError:
raise KeyError("Key is not exists") | def max(self, property) | Getting the maximum value from the prepared data
:@param property
:@type property: string
:@return object
:@throws KeyError | 5.873838 | 5.248673 | 1.119109 |
self.__prepare()
return self.sum(property) / self.count() | def avg(self, property) | Getting average according to given property
:@param property
:@type property: string
:@return average: int/float | 9.635018 | 14.461207 | 0.666267 |
if size == 0:
raise ValueError('Invalid chunk size')
self.__prepare()
_new_content = []
while(len(self._json_data) > 0):
_new_content.append(self._json_data[0:size])
self._json_data = self._json_data[size:]
self._json_data = _new_c... | def chunk(self, size=0) | Group the resulted collection to multiple chunk
:@param size: 0
:@type size: integer
:@return Chunked List | 3.211971 | 3.052901 | 1.052105 |
self.__prepare()
group_data = {}
for data in self._json_data:
if data[property] not in group_data:
group_data[data[property]] = []
group_data[data[property]].append(data)
self._json_data = group_data
return self | def group_by(self, property) | Getting the grouped result by the given property
:@param property
:@type property: string
:@return self | 2.687525 | 2.781546 | 0.966198 |
self.__prepare()
if isinstance(self._json_data, list):
if order == "asc":
self._json_data = sorted(self._json_data)
else:
self._json_data = sorted(self._json_data, reverse=True)
return self | def sort(self, order="asc") | Getting the sorted result of the given list
:@param order: "asc"
:@type order: string
:@return self | 2.635971 | 2.912572 | 0.905032 |
self.__prepare()
if isinstance(self._json_data, list):
if order == "asc":
self._json_data = sorted(
self._json_data,
key=lambda x: x.get(property)
)
else:
self._json_data = sorted(
... | def sort_by(self, property, order="asc") | Getting the sorted result by the given property
:@param property, order: "asc"
:@type property, order: string
:@return self | 2.102407 | 2.33539 | 0.900238 |
if (op not in self.condition_mapper):
raise ValueError('Invalid where condition given')
func = getattr(self, self.condition_mapper.get(op))
return func(x, y) | def _match(self, x, op, y) | Compare the given `x` and `y` based on `op`
:@param x, y, op
:@type x, y: mixed
:@type op: string
:@return bool
:@throws ValueError | 6.551592 | 6.581097 | 0.995517 |
for super_class in _get_base_classes(sys._getframe(2), method.__globals__):
if hasattr(super_class, method.__name__):
super_method = getattr(super_class, method.__name__)
if hasattr(super_method, "__finalized__"):
finalized = getattr(super_method, "__finalized__"... | def overrides(method) | Decorator to indicate that the decorated method overrides a method in
superclass.
The decorator code is executed while loading class. Using this method
should have minimal runtime performance implications.
This is based on my idea about how to do this and fwc:s highly improved
algorithm for the imp... | 2.917456 | 2.863685 | 1.018777 |
co, lasti = frame.f_code, frame.f_lasti
code = co.co_code
extends = []
for (op, oparg) in op_stream(code, lasti):
if op in dis.hasconst:
if type(co.co_consts[oparg]) == str:
extends = []
elif op in dis.hasname:
if dis.opname[op] == 'LOAD_NAME... | def _get_base_class_names(frame) | Get baseclass names from the code object | 2.286297 | 2.278569 | 1.003392 |
if message.get_content_charset():
return message.get_content_charset()
if message.get_charset():
return message.get_charset()
return default | def get_charset(message, default="utf-8") | Get the message charset | 2.288245 | 2.085369 | 1.097285 |
file = os.path.join(os.path.dirname(__file__),
'assets',
'tlds-alpha-by-domain.txt')
with open(file) as fobj:
return [elem for elem in fobj.read().lower().splitlines()[1:]
if "--" not in elem] | def load_tlds() | Load all legal TLD extensions from assets | 3.908259 | 3.496309 | 1.117824 |
rval = []
loc = 0
for match in URLRE.finditer(mesg):
if loc < match.start():
rval.append(Chunk(mesg[loc:match.start()], None))
# Turn email addresses into mailto: links
email = match.group("email")
if email and "mailto" not in email:
mailto = "... | def parse_text_urls(mesg) | Parse a block of text, splitting it into its url and non-url
components. | 2.807629 | 2.66979 | 1.051629 |
rval = []
start = 0
length = 0
while start < len(lst):
usedfirst = False
usedlast = False
# Extend to the next match.
while start + length < len(lst) and length < before_context + 1 \
and not pred(lst[start + length]):
length += 1
... | def extract_with_context(lst, pred, before_context, after_context) | Extract URL and context from a given chunk. | 3.141823 | 3.081106 | 1.019706 |
lines = NLRE.split(mesg)
# The number of lines of context above to provide.
# above_context = 1
# The number of lines of context below to provide.
# below_context = 1
# Plan here is to first transform lines into the form
# [line_fragments] where each fragment is a chunk as
# seen ... | def extracturls(mesg) | Given a text message, extract all the URLs found in the message, along
with their surrounding context. The output is a list of sequences of Chunk
objects, corresponding to the contextual regions extracted from the string. | 7.787115 | 7.299427 | 1.066812 |
chunk = HTMLChunker()
chunk.feed(mesg)
chunk.close()
# above_context = 1
# below_context = 1
def somechunkisurl(chunks):
for chnk in chunks:
if chnk.url is not None:
return True
return False
return extract_with_context(chunk.rval, somechunki... | def extracthtmlurls(mesg) | Extract URLs with context from html type message. Similar to extracturls. | 6.473584 | 6.050926 | 1.06985 |
try:
strg = byt.decode(enc)
except UnicodeDecodeError as err:
strg = "Unable to decode message:\n{}\n{}".format(str(byt), err)
except (AttributeError, UnicodeEncodeError):
# If byt is already a string, just return it
return byt
return strg | def decode_bytes(byt, enc='utf-8') | Given a string or bytes input, return a string.
Args: bytes - bytes or string
enc - encoding to use for decoding the byte string. | 3.511358 | 3.768011 | 0.931886 |
# We avoid the get_payload decoding machinery for raw
# content-transfer-encodings potentially containing non-ascii characters,
# such as 8bit or binary, as these are encoded using raw-unicode-escape which
# seems to prevent subsequent utf-8 decoding.
cte = str(msg.get('content-transfer-encodin... | def decode_msg(msg, enc='utf-8') | Decodes a message fragment.
Args: msg - A Message object representing the fragment
enc - The encoding to use for decoding the message | 9.067189 | 9.484307 | 0.95602 |
# Written as a generator so I can easily choose only
# one subpart in the future (e.g., for
# multipart/alternative). Actually, I might even add
# a browser for the message structure?
enc = get_charset(msg)
if msg.is_multipart():
for part in msg.get_payload():
for chunk... | def msgurls(msg, urlidx=1) | Main entry function for urlscan.py | 4.15348 | 4.221483 | 0.983891 |
cols = ((cols - 6) * .85) # 6 cols for urlref and don't use while line
if shorten is False or len(url) < cols:
return url
split = int(cols * .5)
return url[:split] + "..." + url[-split:] | def shorten_url(url, cols, shorten) | Shorten long URLs to fit on one line. | 8.965005 | 8.307626 | 1.07913 |
grp = []
res = []
for item in items:
if isinstance(item, urwid.Divider):
res.append(grp)
grp = [items[0]]
else:
grp.append(item)
res.append(grp)
return res[1:] | def grp_list(items) | Organize list of items [a,2,3,4,a,4,2,a,1, etc...] like:
[[a,2,3,4], [a,4,2], [a,1]], where 'a' is a urwid.Divider | 3.269502 | 2.634083 | 1.24123 |
if search:
pat = re.compile("({})".format(re.escape(search)), re.IGNORECASE)
else:
return text
final = pat.split(text)
final = [(attr, i) if i.lower() == search.lower() else i for i in final]
return final | def splittext(text, search, attr) | Split a text string by search string and add Urwid display attribute to
the search term.
Args: text - string
search - search string
attr - attribute string to add
Returns: urwid markup list ["string", ("default", " mo"), "re string"]
for search="mo", text="string more stri... | 3.292381 | 4.410905 | 0.746419 |
self.loop = urwid.MainLoop(self.top, self.palettes[self.palette_names[0]], screen=self.tui,
handle_mouse=False, input_filter=self.handle_keys,
unhandled_input=self.unhandled)
self.loop.run() | def main(self) | Urwid main event loop | 4.88419 | 4.094387 | 1.192899 |
for j, k in enumerate(keys):
if self.search is True:
text = "Search: {}".format(self.search_string)
if k == 'enter':
# Catch 'enter' key to prevent opening URL in mkbrowseto
self.enter = True
if not ... | def handle_keys(self, keys, raw) | Handle widget default keys
- 'Enter' or 'space' to load URL
- 'Enter' to end search mode
- add 'space' to search string in search mode
- Workaround some small positioning bugs | 6.229872 | 5.881489 | 1.059234 |
self.key = key
self.size = self.tui.get_cols_rows()
if self.search is True:
if self.enter is False and self.no_matches is False:
if len(key) == 1 and key.isprintable():
self.search_string += key
self._search()
e... | def unhandled(self, key) | Handle other keyboard actions not handled by the ListBox widget. | 5.694319 | 5.460797 | 1.042763 |
load_text = "Loading URL..." if not self.run else "Executing: {}".format(self.run)
if os.environ.get('BROWSER') not in ['elinks', 'links', 'w3m', 'lynx']:
self._footer_start_thread(load_text, 5) | def _open_url(self) | <Enter> or <space> | 12.242072 | 11.194412 | 1.093588 |
if self.help_menu is False:
self.focus_pos_saved = self.top.body.focus_position
help_men = "\n".join(["{} - {}".format(i, j.__name__.strip('_'))
for i, j in self.keys.items() if j.__name__ !=
'_digits'])
... | def _help_menu(self) | F1 | 4.604392 | 4.536884 | 1.01488 |
if self.urls:
self.search = True
if self.compact is True:
self.compact = False
self.items, self.items_com = self.items_com, self.items
else:
return
self.no_matches = False
self.search_string = ""
# Reset... | def _search_key(self) | / | 6.677633 | 6.470256 | 1.032051 |
self.number += self.key
try:
if self.compact is False:
self.top.body.focus_position = \
self.items.index(self.items_com[max(int(self.number) - 1, 0)])
else:
self.top.body.focus_position = \
self.item... | def _digits(self) | 0-9 | 5.957046 | 5.735246 | 1.038673 |
# Goto top of the list
self.top.body.focus_position = 2 if self.compact is False else 0
self.top.keypress(self.size, "") | def _top(self) | g | 18.141279 | 18.307993 | 0.990894 |
# Goto bottom of the list
self.top.body.focus_position = len(self.items) - 1
self.top.keypress(self.size, "") | def _bottom(self) | G | 12.95962 | 13.759462 | 0.94187 |
# Toggle shortened URL for selected item
fpo = self.top.body.focus_position
url_idx = len([i for i in self.items[:fpo + 1]
if isinstance(i, urwid.Columns)]) - 1
if self.compact is False and fpo <= 1:
return
url = self.urls[url_idx]
... | def _shorten(self) | s | 6.963365 | 6.646252 | 1.047713 |
# Toggle all shortened URLs
self.shorten = not self.shorten
urls = iter(self.urls)
for item in self.items:
# Each Column has (Text, Button). Update the Button label
if isinstance(item, urwid.Columns):
item[1].set_label(shorten_url(next(url... | def _all_shorten(self) | S | 7.652315 | 7.632544 | 1.00259 |
# Toggle all escaped URLs
self.unesc = not self.unesc
self.urls, self.urls_unesc = self.urls_unesc, self.urls
urls = iter(self.urls)
for item in self.items:
# Each Column has (Text, Button). Update the Button label
if isinstance(item, urwid.Column... | def _all_escape(self) | u | 7.875914 | 7.780757 | 1.01223 |
# Show/hide context
if self.search_string:
# Reset search when toggling compact mode
footerwid = urwid.AttrMap(urwid.Text(""), 'default')
self.top.footer = footerwid
self.search_string = ""
self.items = self.items_orig
fpo = se... | def _context(self) | c | 6.28883 | 6.133616 | 1.025305 |
# Copy highlighted url to clipboard
fpo = self.top.body.focus_position
url_idx = len([i for i in self.items[:fpo + 1]
if isinstance(i, urwid.Columns)]) - 1
if self.compact is False and fpo <= 1:
return
url = self.urls[url_idx]
i... | def _clipboard(self, pri=False) | C | 5.041403 | 4.98852 | 1.010601 |
# Loop through available palettes
self.palette_idx += 1
try:
self.loop.screen.register_palette(self.palettes[self.palette_names[self.palette_idx]])
except IndexError:
self.loop.screen.register_palette(self.palettes[self.palette_names[0]])
self... | def _palette(self) | p | 3.156497 | 3.17129 | 0.995335 |
# Create ~/.config/urlscan/config.json if if doesn't exist
if not exists(self.conf):
try:
# Python 2/3 compatible recursive directory creation
os.makedirs(dirname(expanduser(self.conf)))
except OSError as err:
if errno.EEXI... | def _config_create(self) | --genconf | 4.090739 | 3.920522 | 1.043417 |
footerwid = urwid.AttrMap(urwid.Text(text), 'footer')
self.top.footer = footerwid
load_thread = Thread(target=self._loading_thread, args=(time,))
load_thread.daemon = True
load_thread.start() | def _footer_start_thread(self, text, time) | Display given text in the footer. Clears after <time> seconds | 3.698993 | 3.789637 | 0.976081 |
sleep(time)
self.number = "" # Clear URL selection number
text = "Search: {}".format(self.search_string)
if self.search_string:
footer = 'search'
else:
footer = 'default'
text = ""
footerwid = urwid.AttrMap(urwid.Text(text), f... | def _loading_thread(self, time) | Simple thread to wait <time> seconds after launching a URL or
displaying a URL selection number, clearing the screen and clearing the
footer loading message. | 8.109984 | 6.557828 | 1.236687 |
text = "Search: {}".format(self.search_string)
footerwid = urwid.AttrMap(urwid.Text(text), 'footer')
self.top.footer = footerwid
search_items = []
for grp in self.items_org:
done = False
for idx, item in enumerate(grp):
if isinstan... | def _search(self) | Search - search URLs and text. | 2.799625 | 2.753879 | 1.016611 |
self.tui.clear()
canvas = self.top.render(size, focus=True)
self.tui.draw_screen(size, canvas) | def draw_screen(self, size) | Render curses screen | 7.332654 | 6.412956 | 1.143413 |
# Try-except block to work around webbrowser module bug
# https://bugs.python.org/issue31014
try:
browser = os.environ['BROWSER']
except KeyError:
pass
else:
del os.environ['BROWSER']
webbrowser.register(browser, None, webb... | def mkbrowseto(self, url) | Create the urwid callback function to open the web browser or call
another function with the URL. | 5.073786 | 4.824681 | 1.051631 |
cols, _ = urwid.raw_display.Screen().get_cols_rows()
items = []
urls = []
first = True
for group, usedfirst, usedlast in extractedurls:
if first:
first = False
items.append(urwid.Divider(div_char='-', top=1, bottom=1))
... | def process_urls(self, extractedurls, dedupe, shorten) | Process the 'extractedurls' and ready them for either the curses browser
or non-interactive output
Args: extractedurls
dedupe - Remove duplicate URLs from list
Returns: items - List of widgets for the ListBox
urls - List of all URLs | 3.894762 | 3.811526 | 1.021838 |
if os.getenv(USER_HOME) is not None and os.access(os.getenv(USER_HOME),
os.W_OK):
return os.path.join(os.getenv(USER_HOME), KEY_FILE_NAME)
return os.path.join(os.getcwd(), KEY_FILE_NAME) | def _get_key_file_path() | Return the key file path. | 2.622473 | 2.303931 | 1.13826 |
self.client_key = None
if self.key_file_path:
key_file_path = self.key_file_path
else:
key_file_path = self._get_key_file_path()
key_dict = {}
logger.debug('load keyfile from %s', key_file_path);
if os.path.isfile(key_file_path):
... | def load_key_file(self) | Try to load the client key for the current ip. | 2.360444 | 2.127733 | 1.109371 |
if self.client_key is None:
return
if self.key_file_path:
key_file_path = self.key_file_path
else:
key_file_path = self._get_key_file_path()
logger.debug('save keyfile to %s', key_file_path);
with open(key_file_path, 'w+') as f:
... | def save_key_file(self) | Save the current client key. | 2.522074 | 2.350014 | 1.073216 |
file = os.path.join(os.path.dirname(__file__), HANDSHAKE_FILE_NAME)
data = codecs.open(file, 'r', 'utf-8')
raw_handshake = data.read()
handshake = json.loads(raw_handshake)
handshake['payload']['client-key'] = self.client_key
yield from websocket.send(json.dum... | def _send_register_payload(self, websocket) | Send the register payload. | 2.963712 | 2.908913 | 1.018839 |
logger.debug('register on %s', "ws://{}:{}".format(self.ip, self.port));
try:
websocket = yield from websockets.connect(
"ws://{}:{}".format(self.ip, self.port), timeout=self.timeout_connect)
except:
logger.error('register failed to connect to %s... | def _register(self) | Register wrapper. | 2.566332 | 2.542282 | 1.00946 |
loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
loop.run_until_complete(self._register()) | def register(self) | Pair client with tv. | 2.489926 | 2.351658 | 1.058796 |
logger.debug('send command to %s', "ws://{}:{}".format(self.ip, self.port));
try:
websocket = yield from websockets.connect(
"ws://{}:{}".format(self.ip, self.port), timeout=self.timeout_connect)
except:
logger.debug('command failed to connect to ... | def _command(self, msg) | Send a command to the tv. | 2.988117 | 3.003161 | 0.994991 |
self.command_count += 1
if payload is None:
payload = {}
message = {
'id': "{}_{}".format(type, self.command_count),
'type': request_type,
'uri': "ssap://{}".format(uri),
'payload': payload,
}
self.last_respo... | def command(self, request_type, uri, payload) | Build and send a command. | 2.60436 | 2.57375 | 1.011893 |
icon_encoded_string = ''
icon_extension = ''
if icon_path is not None:
icon_extension = os.path.splitext(icon_path)[1][1:]
with open(icon_path, 'rb') as icon_file:
icon_encoded_string = base64.b64encode(icon_file.read()).decode('ascii')
... | def send_message(self, message, icon_path=None) | Show a floating message. | 2.40607 | 2.240726 | 1.073791 |
self.request(EP_GET_APPS)
return {} if self.last_response is None else self.last_response.get('payload').get('launchPoints') | def get_apps(self) | Return all apps. | 11.190392 | 9.336445 | 1.198571 |
self.request(EP_GET_CURRENT_APP_INFO)
return None if self.last_response is None else self.last_response.get('payload').get('appId') | def get_current_app(self) | Get the current app id. | 7.216088 | 6.054976 | 1.191762 |
self.request(EP_GET_SERVICES)
return {} if self.last_response is None else self.last_response.get('payload').get('services') | def get_services(self) | Get all services. | 7.635472 | 6.302168 | 1.211563 |
self.request(EP_GET_SOFTWARE_INFO)
return {} if self.last_response is None else self.last_response.get('payload') | def get_software_info(self) | Return the current software status. | 7.784943 | 6.449805 | 1.207004 |
self.request(EP_GET_INPUTS)
return {} if self.last_response is None else self.last_response.get('payload').get('devices') | def get_inputs(self) | Get all inputs. | 9.17455 | 7.697268 | 1.191923 |
self.request(EP_GET_AUDIO_STATUS)
return {} if self.last_response is None else self.last_response.get('payload') | def get_audio_status(self) | Get the current audio status | 7.514224 | 6.586007 | 1.140938 |
self.request(EP_GET_VOLUME)
return 0 if self.last_response is None else self.last_response.get('payload').get('volume') | def get_volume(self) | Get the current volume. | 6.758111 | 5.575374 | 1.212136 |
volume = max(0, volume)
self.request(EP_SET_VOLUME, {
'volume': volume
}) | def set_volume(self, volume) | Set volume. | 7.109165 | 6.439437 | 1.104004 |
self.request(EP_GET_TV_CHANNELS)
return {} if self.last_response is None else self.last_response.get('payload').get('channelList') | def get_channels(self) | Get all tv channels. | 7.733974 | 5.447042 | 1.419849 |
self.request(EP_GET_CURRENT_CHANNEL)
return {} if self.last_response is None else self.last_response.get('payload') | def get_current_channel(self) | Get the current tv channel. | 7.376833 | 6.024404 | 1.224492 |
self.request(EP_GET_CHANNEL_INFO)
return {} if self.last_response is None else self.last_response.get('payload') | def get_channel_info(self) | Get the current channel info. | 7.430581 | 6.038619 | 1.23051 |
for res in pkg_resources.iter_entry_points(pgroup):
try:
yield res.load()
except ImportError:
if safe:
continue
raise | def _load_plugins_itr(pgroup, safe=True) | .. seealso:: the doc of :func:`load_plugins` | 2.99735 | 2.804958 | 1.06859 |
itr = anyconfig.utils.concat(((k, v) for k in ks) for ks, v in items)
return list((k, sort_fn(t[1] for t in g))
for k, g
in anyconfig.utils.groupby(itr, operator.itemgetter(0))) | def select_by_key(items, sort_fn=sorted) | :param items: A list of tuples of keys and values, [([key], val)]
:return: A list of tuples of key and values, [(key, [val])]
>>> select_by_key([(["a", "aaa"], 1), (["b", "bb"], 2), (["a"], 3)])
[('a', [1, 3]), ('aaa', [1]), ('b', [2]), ('bb', [2])] | 6.849983 | 6.813782 | 1.005313 |
if key == "type":
kfn = operator.methodcaller(key)
res = sorted(((k, sort_by_prio(g)) for k, g
in anyconfig.utils.groupby(prs, kfn)),
key=operator.itemgetter(0))
elif key == "extensions":
res = select_by_key(((p.extensions(), p) for p in p... | def list_by_x(prs, key) | :param key: Grouping key, "type" or "extensions"
:return:
A list of :class:`Processor` or its children classes grouped by
given 'item', [(cid, [:class:`Processor`)]] by default | 4.847967 | 4.339031 | 1.117293 |
return sorted((p for p in prs if predicate(p)),
key=operator.methodcaller("priority"), reverse=True) | def findall_with_pred(predicate, prs) | :param predicate: any callable to filter results
:param prs: A list of :class:`anyconfig.models.processor.Processor` classes
:return: A list of appropriate processor classes or [] | 4.71887 | 5.915987 | 0.797647 |
if isinstance(type_or_id, cls):
return type_or_id
if type(type_or_id) == type(cls) and issubclass(type_or_id, cls):
return type_or_id()
return None | def maybe_processor(type_or_id, cls=anyconfig.models.processor.Processor) | :param type_or_id:
Type of the data to process or ID of the processor class or
:class:`anyconfig.models.processor.Processor` class object or its
instance
:param cls: A class object to compare with 'type_or_id'
:return: Processor instance or None | 2.233312 | 2.439941 | 0.915314 |
def pred(pcls):
return pcls.cid() == type_or_id or pcls.type() == type_or_id
pclss = findall_with_pred(pred, prs)
if not pclss:
raise UnknownProcessorTypeError(type_or_id)
return pclss | def find_by_type_or_id(type_or_id, prs) | :param type_or_id: Type of the data to process or ID of the processor class
:param prs: A list of :class:`anyconfig.models.processor.Processor` classes
:return:
A list of processor classes to process files of given data type or
processor 'type_or_id' found by its ID
:raises: UnknownProcessor... | 5.471818 | 4.378311 | 1.249756 |
def pred(pcls):
return fileext in pcls.extensions()
pclss = findall_with_pred(pred, prs)
if not pclss:
raise UnknownFileTypeError("file extension={}".format(fileext))
return pclss | def find_by_fileext(fileext, prs) | :param fileext: File extension
:param prs: A list of :class:`anyconfig.models.processor.Processor` classes
:return: A list of processor class to processor files with given extension
:raises: UnknownFileTypeError | 7.635281 | 5.982654 | 1.276236 |
if not isinstance(obj, IOInfo):
obj = anyconfig.ioinfo.make(obj)
return find_by_fileext(obj.extension, prs) | def find_by_maybe_file(obj, prs) | :param obj:
a file path, file or file-like object, pathlib.Path object or an
'anyconfig.globals.IOInfo' (namedtuple) object
:param cps_by_ext: A list of processor classes
:return: A list of processor classes to process given (maybe) file
:raises: UnknownFileTypeError | 9.8114 | 7.752546 | 1.265571 |
if (obj is None or not obj) and forced_type is None:
raise ValueError("The first argument 'obj' or the second argument "
"'forced_type' must be something other than "
"None or False.")
if forced_type is None:
pclss = find_by_maybe_file(obj,... | def findall(obj, prs, forced_type=None,
cls=anyconfig.models.processor.Processor) | :param obj:
a file path, file, file-like object, pathlib.Path object or an
'anyconfig.globals.IOInfo` (namedtuple) object
:param prs: A list of :class:`anyconfig.models.processor.Processor` classes
:param forced_type:
Forced processor type of the data to process or ID of the processor
... | 5.654773 | 5.463917 | 1.03493 |
if forced_type is not None:
processor = maybe_processor(forced_type, cls=cls)
if processor is not None:
return processor
pclss = findall(obj, prs, forced_type=forced_type, cls=cls)
return pclss[0]() | def find(obj, prs, forced_type=None, cls=anyconfig.models.processor.Processor) | :param obj:
a file path, file, file-like object, pathlib.Path object or an
'anyconfig.globals.IOInfo' (namedtuple) object
:param prs: A list of :class:`anyconfig.models.processor.Processor` classes
:param forced_type:
Forced processor type of the data to process or ID of the processor
... | 3.668751 | 4.20105 | 0.873294 |
for pcls in pclss:
if pcls.cid() not in self._processors:
self._processors[pcls.cid()] = pcls | def register(self, *pclss) | :param pclss: A list of :class:`Processor` or its children classes | 3.691627 | 3.249989 | 1.135889 |
prs = self._processors.values()
if sort:
return sorted(prs, key=operator.methodcaller("cid"))
return prs | def list(self, sort=False) | :param sort: Result will be sorted if it's True
:return: A list of :class:`Processor` or its children classes | 9.259993 | 7.874139 | 1.176001 |
prs = self._processors
return sorted(((cid, [prs[cid]]) for cid in sorted(prs.keys())),
key=operator.itemgetter(0)) | def list_by_cid(self) | :return:
A list of :class:`Processor` or its children classes grouped by
each cid, [(cid, [:class:`Processor`)]] | 10.567949 | 5.14639 | 2.053468 |
prs = self._processors
if item is None or item == "cid": # Default.
res = [(cid, [prs[cid]]) for cid in sorted(prs.keys())]
elif item in ("type", "extensions"):
res = list_by_x(prs.values(), item)
else:
raise ValueError("keyword argument 'i... | def list_by_x(self, item=None) | :param item: Grouping key, one of "cid", "type" and "extensions"
:return:
A list of :class:`Processor` or its children classes grouped by
given 'item', [(cid, [:class:`Processor`)]] by default | 5.94496 | 3.711585 | 1.601731 |
if key in ("cid", "type"):
return sorted(set(operator.methodcaller(key)(p)
for p in self._processors.values()))
if key == "extension":
return sorted(k for k, _v in self.list_by_x("extensions"))
raise ValueError("keyword argument 'ke... | def list_x(self, key=None) | :param key: Which of key to return from "cid", "type", and "extention"
:return: A list of x 'key' | 6.33558 | 5.960032 | 1.063011 |
return [p() for p in findall(obj, self.list(),
forced_type=forced_type, cls=cls)] | def findall(self, obj, forced_type=None,
cls=anyconfig.models.processor.Processor) | :param obj:
a file path, file, file-like object, pathlib.Path object or an
'anyconfig.globals.IOInfo' (namedtuple) object
:param forced_type: Forced processor type to find
:param cls: A class object to compare with 'ptype'
:return: A list of instances of processor classe... | 6.426969 | 8.566407 | 0.750253 |
return find(obj, self.list(), forced_type=forced_type, cls=cls) | def find(self, obj, forced_type=None,
cls=anyconfig.models.processor.Processor) | :param obj:
a file path, file, file-like object, pathlib.Path object or an
'anyconfig.globals.IOInfo' (namedtuple) object
:param forced_type: Forced processor type to find
:param cls: A class object to compare with 'ptype'
:return: an instance of processor class to proce... | 5.169708 | 12.703199 | 0.406961 |
options = common.filter_from_options("ac_dict", options)
if "ac_safe" in options:
options["typ"] = "safe" # Override it.
iopts = anyconfig.utils.filter_options(_YAML_INIT_KWARGS, options)
oopts = anyconfig.utils.filter_options(_YAML_INSTANCE_MEMBERS, options)
yml = ryaml.YAML(**iopt... | def yml_fnc(fname, *args, **options) | :param fname:
"load" or "dump", not checked but it should be OK.
see also :func:`yml_load` and :func:`yml_dump`
:param args: [stream] for load or [cnf, stream] for dump
:param options: keyword args may contain "ac_safe" to load/dump safely | 6.664323 | 6.216505 | 1.072037 |
ret = yml_fnc("load", stream, **options)
if ret is None:
return container()
return ret | def yml_load(stream, container, **options) | .. seealso:: :func:`anyconfig.backend.yaml.pyyaml.yml_load` | 8.651622 | 8.541088 | 1.012941 |
try:
return ET.iterparse(xmlfile, events=("start-ns", ))
except TypeError:
return ET.iterparse(xmlfile, events=(b"start-ns", )) | def _iterparse(xmlfile) | Avoid bug in python 3.{2,3}. See http://bugs.python.org/issue9257.
:param xmlfile: XML file or file-like object | 2.901761 | 3.201723 | 0.906312 |
nspaces = options.get("nspaces", None)
if nspaces is not None:
matched = _ET_NS_RE.match(tag)
if matched:
(uri, tag) = matched.groups()
prefix = nspaces.get(uri, False)
if prefix:
return "%s:%s" % (prefix, tag)
return tag | def _tweak_ns(tag, **options) | :param tag: XML tag element
:param nspaces: A namespaces dict, {uri: prefix}
:param options: Extra keyword options may contain 'nspaces' keyword option
provide a namespace dict, {uri: prefix}
>>> _tweak_ns("a", nspaces={})
'a'
>>> _tweak_ns("a", nspaces={"http://example.com/ns/val/": "val"}... | 3.286595 | 3.783993 | 0.868552 |
key_itr = anyconfig.compat.from_iterable(d.keys() for d in dics)
return len(set(key_itr)) == sum(len(d) for d in dics) | def _dicts_have_unique_keys(dics) | :param dics: [<dict or dict-like object>], must not be [] or [{...}]
:return: True if all keys of each dict of 'dics' are unique
# Enable the followings if to allow dics is [], [{...}]:
# >>> all(_dicts_have_unique_keys([d]) for [d]
# ... in ({}, {'a': 0}, {'a': 1, 'b': 0}))
# True
# >>> _d... | 6.706601 | 8.21352 | 0.816532 |
dic_itr = anyconfig.compat.from_iterable(d.items() for d in dics)
return container(anyconfig.compat.OrderedDict(dic_itr)) | def _merge_dicts(dics, container=dict) | :param dics: [<dict/-like object must not have same keys each other>]
:param container: callble to make a container object
:return: <container> object
>>> _merge_dicts(({}, ))
{}
>>> _merge_dicts(({'a': 1}, ))
{'a': 1}
>>> sorted(kv for kv in _merge_dicts(({'a': 1}, {'b': 2})).items())
... | 8.607315 | 11.131159 | 0.773263 |
if val and options.get("ac_parse_value", False):
return anyconfig.parser.parse_single(val)
return val | def _parse_text(val, **options) | :return: Parsed value or value itself depends on 'ac_parse_value' | 12.935771 | 6.247931 | 2.070409 |
elem.text = elem.text.strip()
if elem.text:
etext = _parse_text(elem.text, **options)
if len(elem) or elem.attrib:
subdic[text] = etext
else:
dic[elem.tag] = etext | def _process_elem_text(elem, dic, subdic, text="@text", **options) | :param elem: ET Element object which has elem.text
:param dic: <container> (dict[-like]) object converted from elem
:param subdic: Sub <container> object converted from elem
:param options:
Keyword options, see the description of :func:`elem_to_container` for
more details.
:return: None... | 3.022506 | 3.4173 | 0.884472 |
adic = dict((_tweak_ns(a, **options), v) for a, v in elem.attrib.items())
if options.get("ac_parse_value", False):
return container(dict((k, anyconfig.parser.parse_single(v))
for k, v in adic.items()))
return container(adic) | def _parse_attrs(elem, container=dict, **options) | :param elem: ET Element object has attributes (elem.attrib)
:param container: callble to make a container object
:return: Parsed value or value itself depends on 'ac_parse_value' | 7.007162 | 5.573742 | 1.257174 |
adic = _parse_attrs(elem, container=container, **options)
if not elem.text and not len(elem) and options.get("merge_attrs"):
dic[elem.tag] = adic
else:
subdic[attrs] = adic | def _process_elem_attrs(elem, dic, subdic, container=dict, attrs="@attrs",
**options) | :param elem: ET Element object or None
:param dic: <container> (dict[-like]) object converted from elem
:param subdic: Sub <container> object converted from elem
:param options:
Keyword options, see the description of :func:`elem_to_container` for
more details.
:return: None but updatin... | 4.57564 | 5.893813 | 0.776346 |
cdics = [elem_to_container(c, container=container, **options)
for c in elem]
merge_attrs = options.get("merge_attrs", False)
sdics = [container(elem.attrib) if merge_attrs else subdic] + cdics
if _dicts_have_unique_keys(sdics): # ex. <a><b>1</b><c>c</c></a>
dic[elem.tag] = _m... | def _process_children_elems(elem, dic, subdic, container=dict,
children="@children", **options) | :param elem: ET Element object or None
:param dic: <container> (dict[-like]) object converted from elem
:param subdic: Sub <container> object converted from elem
:param container: callble to make a container object
:param children: Tag for children nodes
:param options:
Keyword options, see ... | 5.178242 | 5.189109 | 0.997906 |
dic = container()
if elem is None:
return dic
elem.tag = _tweak_ns(elem.tag, **options) # {ns}tag -> ns_prefix:tag
subdic = dic[elem.tag] = container()
options["container"] = container
if elem.text:
_process_elem_text(elem, dic, subdic, **options)
if elem.attrib:
... | def elem_to_container(elem, container=dict, **options) | Convert XML ElementTree Element to a collection of container objects.
Elements are transformed to a node under special tagged nodes, attrs, text
and children, to store the type of these elements basically, however, in
some special cases like the followings, these nodes are attached to the
parent node d... | 3.759933 | 3.868504 | 0.971935 |
if not all(nt in options for nt in _TAGS):
tags = options.get("tags", {})
for ntype, tag in _TAGS.items():
options[ntype] = tags.get(ntype, tag)
return options | def _complement_tag_options(options) | :param options: Keyword options :: dict
>>> ref = _TAGS.copy()
>>> ref["text"] = "#text"
>>> opts = _complement_tag_options({"tags": {"text": ref["text"]}})
>>> del opts["tags"] # To simplify comparison.
>>> sorted(opts.items())
[('attrs', '@attrs'), ('children', '@children'), ('text', '#text'... | 4.839284 | 4.711285 | 1.027169 |
tree = container()
if root is None:
return tree
if nspaces is not None:
for uri, prefix in nspaces.items():
root.attrib["xmlns:" + prefix if prefix else "xmlns"] = uri
return elem_to_container(root, container=container, nspaces=nspaces,
**_... | def root_to_container(root, container=dict, nspaces=None, **options) | Convert XML ElementTree Root Element to a collection of container objects.
:param root: etree root object or None
:param container: callble to make a container object
:param nspaces: A namespaces dict, {uri: prefix} or None
:param options: Keyword options,
- tags: Dict of tags for special node... | 4.388606 | 4.494826 | 0.976368 |
for attr, val in anyconfig.compat.iteritems(obj):
parent.set(attr, to_str(val)) | def _elem_set_attrs(obj, parent, to_str) | :param obj: Container instance gives attributes of XML Element
:param parent: XML ElementTree parent node object
:param to_str: Callable to convert value to string or None
:param options: Keyword options, see :func:`container_to_etree`
:return: None but parent will be modified | 5.255966 | 8.171075 | 0.64324 |
for child in children_nodes: # child should be a dict-like object.
for ckey, cval in anyconfig.compat.iteritems(child):
celem = ET.Element(ckey)
container_to_etree(cval, parent=celem, **options)
yield celem | def _elem_from_descendants(children_nodes, **options) | :param children_nodes: A list of child dict objects
:param options: Keyword options, see :func:`container_to_etree` | 6.826037 | 5.625661 | 1.213375 |
elem = ET.Element(key)
vals = val if anyconfig.utils.is_iterable(val) else [val]
for val_ in vals:
container_to_etree(val_, parent=elem, to_str=to_str, **options)
if parent is None: # 'elem' is the top level etree.
return elem
parent.append(elem)
return parent | def _get_or_update_parent(key, val, to_str, parent=None, **options) | :param key: Key of current child (dict{,-like} object)
:param val: Value of current child (dict{,-like} object or [dict{,...}])
:param to_str: Callable to convert value to string
:param parent: XML ElementTree parent node object or None
:param options: Keyword options, see :func:`container_to_etree` | 5.463691 | 4.569892 | 1.195584 |
if to_str is None:
to_str = _to_str_fn(**options)
if not anyconfig.utils.is_dict_like(obj):
if parent is not None and obj:
parent.text = to_str(obj) # Parent is a leaf text node.
return parent # All attributes and text should be set already.
options = _complement... | def container_to_etree(obj, parent=None, to_str=None, **options) | Convert a dict-like object to XML ElementTree.
:param obj: Container instance to convert to
:param parent: XML ElementTree parent node object or None
:param to_str: Callable to convert value to string or None
:param options: Keyword options,
- tags: Dict of tags for special nodes to keep XML i... | 4.793162 | 4.814039 | 0.995663 |
try:
tree.write(stream, encoding="utf-8", xml_declaration=True)
except TypeError:
tree.write(stream, encoding="unicode", xml_declaration=True) | def etree_write(tree, stream) | Write XML ElementTree 'root' content into 'stream'.
:param tree: XML ElementTree object
:param stream: File or file-like object can write to | 2.002206 | 2.593668 | 0.771959 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.