_id stringlengths 2 7 | title stringlengths 1 88 | partition stringclasses 3
values | text stringlengths 31 13.1k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q270700 | options_getter | test | def options_getter(command_options):
"""Compatibility function to get rid of optparse in management commands after Django 1.10.
:param tuple command_options: tuple with `CommandOption` objects.
"""
def get_options(option_func=None):
from optparse import make_option
from django.core.management.base import BaseCommand
func = option_func or make_option
options = tuple([func(*option.args, **option.kwargs) for option in command_options])
| python | {
"resource": ""
} |
q270701 | register_items_hook | test | def register_items_hook(func):
"""Registers a hook callable to process tree items right before they are passed to templates.
Callable should be able to:
a) handle ``tree_items`` and ``tree_sender`` key params.
``tree_items`` will contain a list of extended TreeItem objects ready to pass to template.
``tree_sender`` will contain navigation type identifier
(e.g.: `menu`, `sitetree`, `breadcrumbs`, `menu.children`, `sitetree.children`)
b) return a list of extended TreeItems objects to pass to template.
Example::
# Put the following code somewhere where it'd be triggered as expected. E.g. in app view.py.
# First import the register function.
from sitetree.sitetreeapp import register_items_hook
# The following function will be used as items processor.
def my_items_processor(tree_items, tree_sender):
# Suppose we want to process only menu child items.
if tree_sender == 'menu.children':
# Lets add 'Hooked: ' to resolved titles of every item.
for item in tree_items:
| python | {
"resource": ""
} |
q270702 | compose_dynamic_tree | test | def compose_dynamic_tree(src, target_tree_alias=None, parent_tree_item_alias=None, include_trees=None):
"""Returns a structure describing a dynamic sitetree.utils
The structure can be built from various sources,
:param str|iterable src: If a string is passed to `src`, it'll be treated as the name of an app,
from where one want to import sitetrees definitions. `src` can be an iterable
of tree definitions (see `sitetree.toolbox.tree()` and `item()` functions).
:param str|unicode target_tree_alias: Static tree alias to attach items from dynamic trees to.
:param str|unicode parent_tree_item_alias: Tree item alias from a static tree to attach items from dynamic trees to.
:param list include_trees: Sitetree aliases to filter `src`.
:rtype: dict
"""
def result(sitetrees=src):
if include_trees is not None:
sitetrees = [tree for tree in sitetrees if tree.alias in include_trees]
return {
'app': src,
'sitetrees': sitetrees,
'tree': target_tree_alias,
| python | {
"resource": ""
} |
q270703 | Cache.init | test | def init(self):
"""Initializes local cache from Django cache."""
# Drop cache flag set by .reset() method.
cache.get('sitetrees_reset') and self.empty(init=False)
self.cache = | python | {
"resource": ""
} |
q270704 | Cache.empty | test | def empty(self, **kwargs):
"""Empties cached sitetree data."""
cache.delete('sitetrees')
| python | {
"resource": ""
} |
q270705 | Cache.get_entry | test | def get_entry(self, entry_name, key):
"""Returns cache entry parameter value by its name.
:param str|unicode entry_name:
| python | {
"resource": ""
} |
q270706 | Cache.update_entry_value | test | def update_entry_value(self, entry_name, key, value):
"""Updates cache entry parameter with new data.
:param str|unicode entry_name:
:param key:
:param value:
"""
| python | {
"resource": ""
} |
q270707 | Cache.set_entry | test | def set_entry(self, entry_name, key, value):
"""Replaces entire cache entry parameter data by its name with new data.
:param str|unicode entry_name:
| python | {
"resource": ""
} |
q270708 | SiteTree.init | test | def init(self, context):
"""Initializes sitetree to handle new request.
:param Context|None context:
"""
self.cache = Cache()
self.current_page_context = context
| python | {
"resource": ""
} |
q270709 | SiteTree.resolve_tree_i18n_alias | test | def resolve_tree_i18n_alias(self, alias):
"""Resolves internationalized tree alias.
Verifies whether a separate sitetree is available for currently active language.
If so, returns i18n alias. If not, returns the initial alias.
:param str|unicode alias:
:rtype: str|unicode
"""
if alias not in _I18N_TREES:
| python | {
"resource": ""
} |
q270710 | SiteTree.current_app_is_admin | test | def current_app_is_admin(self):
"""Returns boolean whether current application is Admin contrib.
:rtype: bool
"""
is_admin = self._current_app_is_admin
if is_admin is None:
context = self.current_page_context
current_app = getattr(
# Try from request.resolver_match.app_name
getattr(context.get('request', None), 'resolver_match', None), 'app_name',
# Try from global context obj.
getattr(context, 'current_app', None))
| python | {
"resource": ""
} |
q270711 | SiteTree.calculate_item_depth | test | def calculate_item_depth(self, tree_alias, item_id, depth=0):
"""Calculates depth of the item in the tree.
:param str|unicode tree_alias:
:param int item_id:
:param int depth:
:rtype: int
"""
item = self.get_item_by_id(tree_alias, item_id)
if hasattr(item, | python | {
"resource": ""
} |
q270712 | SiteTree.get_tree_current_item | test | def get_tree_current_item(self, tree_alias):
"""Resolves current tree item of 'tree_alias' tree matching current
request path against URL of given tree item.
:param str|unicode tree_alias:
:rtype: TreeItemBase
"""
current_item = self._current_items.get(tree_alias, _UNSET)
if current_item is not _UNSET:
if current_item is not None:
current_item.is_current = True # Could be reset by .get_sitetree()
return current_item
current_item = None
if self.current_app_is_admin():
self._current_items[tree_alias] = current_item
return None
# urlquote is an attempt to support non-ascii in url.
current_url = self.current_request.path
if isinstance(current_url, str):
| python | {
"resource": ""
} |
q270713 | SiteTree.url | test | def url(self, sitetree_item, context=None):
"""Resolves item's URL.
:param TreeItemBase sitetree_item: TreeItemBase heir object, 'url' property of which
is processed as URL pattern or simple URL.
:param Context context:
:rtype: str|unicode
"""
context = context or self.current_page_context
resolve_var = self.resolve_var
if not isinstance(sitetree_item, MODEL_TREE_ITEM_CLASS):
sitetree_item = resolve_var(sitetree_item, context)
resolved_url = self._items_urls.get(sitetree_item)
if resolved_url is not None:
return resolved_url
# Resolve only if item's URL is marked as pattern.
if sitetree_item.urlaspattern:
url = sitetree_item.url
view_path = url
all_arguments = []
if ' ' in url:
view_path = url.split(' ')
# We should try to resolve URL parameters from site tree item.
for view_argument in view_path[1:]:
resolved = resolve_var(view_argument)
| python | {
"resource": ""
} |
q270714 | SiteTree.init_tree | test | def init_tree(self, tree_alias, context):
"""Initializes sitetree in memory.
Returns tuple with resolved tree alias and items on success.
On fail returns (None, None).
:param str|unicode tree_alias:
:param Context context:
:rtype: tuple
"""
request = context.get('request', None)
if request is None:
raise SiteTreeError(
'Sitetree requires "django.core.context_processors.request" template context processor to be active. '
'If it is, check that your view pushes request data into the template.')
if id(request) != id(self.current_request):
| python | {
"resource": ""
} |
q270715 | SiteTree.get_current_page_attr | test | def get_current_page_attr(self, attr_name, tree_alias, context):
"""Returns an arbitrary attribute of a sitetree item resolved as current for current page.
:param str|unicode attr_name:
:param str|unicode tree_alias:
:param Context context:
:rtype: str|unicode
"""
tree_alias, sitetree_items = self.init_tree(tree_alias, context)
current_item = self.get_tree_current_item(tree_alias)
if current_item is None:
if settings.DEBUG and RAISE_ITEMS_ERRORS_ON_DEBUG:
raise SiteTreeError(
| python | {
"resource": ""
} |
q270716 | SiteTree.get_ancestor_level | test | def get_ancestor_level(self, current_item, depth=1):
"""Returns ancestor of level `deep` recursively
:param TreeItemBase current_item:
:param int depth:
:rtype: TreeItemBase
"""
if current_item.parent is None:
| python | {
"resource": ""
} |
q270717 | SiteTree.menu | test | def menu(self, tree_alias, tree_branches, context):
"""Builds and returns menu structure for 'sitetree_menu' tag.
:param str|unicode tree_alias:
:param str|unicode tree_branches:
:param Context context:
:rtype: list|str
"""
tree_alias, sitetree_items = self.init_tree(tree_alias, context)
if not sitetree_items:
return ''
tree_branches = self.resolve_var(tree_branches)
parent_isnull = False
parent_ids = []
parent_aliases = []
current_item = self.get_tree_current_item(tree_alias)
self.tree_climber(tree_alias, current_item)
# Support item addressing both through identifiers and aliases.
for branch_id in tree_branches.split(','):
branch_id = branch_id.strip()
if branch_id == ALIAS_TRUNK:
parent_isnull = True
elif branch_id == ALIAS_THIS_CHILDREN and current_item is not None:
branch_id = current_item.id
parent_ids.append(branch_id)
elif branch_id == ALIAS_THIS_ANCESTOR_CHILDREN and current_item is not None:
branch_id = self.get_ancestor_item(tree_alias, current_item).id
parent_ids.append(branch_id)
elif branch_id == ALIAS_THIS_SIBLINGS and current_item is not None and current_item.parent is not None:
branch_id = current_item.parent.id
parent_ids.append(branch_id)
| python | {
"resource": ""
} |
q270718 | SiteTree.check_access | test | def check_access(self, item, context):
"""Checks whether a current user has an access to a certain item.
:param TreeItemBase item:
:param Context context:
:rtype: bool
"""
if hasattr(self.current_request.user.is_authenticated, '__call__'):
authenticated = self.current_request.user.is_authenticated()
else:
authenticated = self.current_request.user.is_authenticated
if item.access_loggedin and not authenticated:
return False
if item.access_guest and authenticated:
return False
if item.access_restricted:
user_perms = self._current_user_permissions
| python | {
"resource": ""
} |
q270719 | SiteTree.breadcrumbs | test | def breadcrumbs(self, tree_alias, context):
"""Builds and returns breadcrumb trail structure for 'sitetree_breadcrumbs' tag.
:param str|unicode tree_alias:
:param Context context:
:rtype: list|str
"""
tree_alias, sitetree_items = self.init_tree(tree_alias, context)
if not sitetree_items:
return ''
current_item = self.get_tree_current_item(tree_alias)
breadcrumbs = []
if current_item is not None:
context_ = self.current_page_context
check_access = self.check_access
get_item_by_id = self.get_item_by_id
def climb(base_item):
"""Climbs up the site tree to build breadcrumb path.
:param TreeItemBase base_item:
"""
if base_item.inbreadcrumbs and not base_item.hidden and check_access(base_item, context_):
| python | {
"resource": ""
} |
q270720 | SiteTree.tree | test | def tree(self, tree_alias, context):
"""Builds and returns tree structure for 'sitetree_tree' tag.
:param str|unicode tree_alias:
:param Context context:
:rtype: list|str
"""
tree_alias, sitetree_items = self.init_tree(tree_alias, context)
if not sitetree_items:
return ''
| python | {
"resource": ""
} |
q270721 | SiteTree.children | test | def children(self, parent_item, navigation_type, use_template, context):
"""Builds and returns site tree item children structure for 'sitetree_children' tag.
:param TreeItemBase parent_item:
:param str|unicode navigation_type: menu, sitetree
:param str|unicode use_template:
:param Context context:
:rtype: list
"""
# Resolve parent item and current tree alias.
parent_item = self.resolve_var(parent_item, context)
| python | {
"resource": ""
} |
q270722 | SiteTree.get_children | test | def get_children(self, tree_alias, item):
"""Returns item's children.
:param str|unicode tree_alias:
:param TreeItemBase|None item:
:rtype: list
"""
if not self.current_app_is_admin():
# We do not | python | {
"resource": ""
} |
q270723 | SiteTree.update_has_children | test | def update_has_children(self, tree_alias, tree_items, navigation_type):
"""Updates 'has_children' attribute for tree items inplace.
:param str|unicode tree_alias:
:param list tree_items:
:param str|unicode navigation_type: sitetree, breadcrumbs, menu
| python | {
"resource": ""
} |
q270724 | SiteTree.filter_items | test | def filter_items(self, items, navigation_type=None):
"""Filters sitetree item's children if hidden and by navigation type.
NB: We do not apply any filters to sitetree in admin app.
:param list items:
:param str|unicode navigation_type: sitetree, breadcrumbs, menu
:rtype: list
"""
if self.current_app_is_admin():
return items
items_filtered = []
context = self.current_page_context
check_access = self.check_access
for item in items:
| python | {
"resource": ""
} |
q270725 | SiteTree.get_ancestor_item | test | def get_ancestor_item(self, tree_alias, base_item):
"""Climbs up the site tree to resolve root item for chosen one.
:param str|unicode tree_alias:
:param TreeItemBase base_item:
:rtype: TreeItemBase
"""
parent = None
if hasattr(base_item, 'parent') and base_item.parent is | python | {
"resource": ""
} |
q270726 | SiteTree.tree_climber | test | def tree_climber(self, tree_alias, base_item):
"""Climbs up the site tree to mark items of current branch.
:param str|unicode tree_alias:
:param TreeItemBase base_item:
"""
if base_item is not None:
base_item.in_current_branch = | python | {
"resource": ""
} |
q270727 | SiteTree.resolve_var | test | def resolve_var(self, varname, context=None):
"""Resolves name as a variable in a given context.
If no context specified page context' is considered as context.
:param str|unicode varname:
:param Context context:
:return:
| python | {
"resource": ""
} |
q270728 | sitetree_tree | test | def sitetree_tree(parser, token):
"""Parses sitetree tag parameters.
Two notation types are possible:
1. Two arguments:
{% sitetree_tree from "mytree" %}
Used to render tree for "mytree" site tree.
2. Four arguments:
{% sitetree_tree from "mytree" template "sitetree/mytree.html" %}
Used to render tree for "mytree" site tree using specific
template "sitetree/mytree.html"
"""
tokens = token.split_contents()
| python | {
"resource": ""
} |
q270729 | sitetree_children | test | def sitetree_children(parser, token):
"""Parses sitetree_children tag parameters.
Six arguments:
{% sitetree_children of someitem for menu template "sitetree/mychildren.html" %}
Used to render child items of specific site tree 'someitem'
using template "sitetree/mychildren.html" for menu navigation.
Basically template argument should contain path to current template itself.
Allowed navigation types: 1) menu; 2) sitetree.
"""
tokens = token.split_contents()
use_template = detect_clause(parser, 'template', tokens)
tokens_num = len(tokens)
clauses_in_places = (
tokens_num == 5 and tokens[1] == 'of' and tokens[3] == 'for' and tokens[4] in ('menu', 'sitetree')
)
| python | {
"resource": ""
} |
q270730 | sitetree_breadcrumbs | test | def sitetree_breadcrumbs(parser, token):
"""Parses sitetree_breadcrumbs tag parameters.
Two notation types are possible:
1. Two arguments:
{% sitetree_breadcrumbs from "mytree" %}
Used to render breadcrumb path for "mytree" site tree.
2. Four arguments:
{% sitetree_breadcrumbs from "mytree" template "sitetree/mycrumb.html" %}
| python | {
"resource": ""
} |
q270731 | sitetree_menu | test | def sitetree_menu(parser, token):
"""Parses sitetree_menu tag parameters.
{% sitetree_menu from "mytree" include "trunk,1,level3" %}
Used to render trunk, branch with id 1 and branch aliased 'level3'
elements from "mytree" site tree as a menu.
These are reserved aliases:
* 'trunk' - items without parents
* 'this-children' - items under item resolved as current for the current page
* 'this-siblings' - items under parent of item resolved as current for
the current page (current item included)
* 'this-ancestor-children' - items under grandparent item (closest to root)
for the item resolved as current for the current page
{% sitetree_menu from "mytree" include "trunk,1,level3" template "sitetree/mymenu.html" %}
"""
| python | {
"resource": ""
} |
q270732 | render | test | def render(context, tree_items, use_template):
"""Render helper is used by template node functions
to render given template with given tree items in context.
"""
context.push()
context['sitetree_items'] = tree_items
if isinstance(use_template, FilterExpression):
| python | {
"resource": ""
} |
q270733 | SimpleNode.for_tag | test | def for_tag(cls, parser, token, preposition, error_hint):
"""Node constructor to be used in tags."""
tokens = token.split_contents()
if len(tokens) >= 3 and tokens[1] == preposition:
as_var = cls.get_as_var(tokens)
tree_alias = parser.compile_filter(tokens[2])
| python | {
"resource": ""
} |
q270734 | get_model_url_name | test | def get_model_url_name(model_nfo, page, with_namespace=False):
"""Returns a URL for a given Tree admin page type."""
prefix = ''
if with_namespace:
| python | {
"resource": ""
} |
q270735 | _reregister_tree_admin | test | def _reregister_tree_admin():
"""Forces unregistration of tree admin class with following re-registration."""
try:
admin.site.unregister(MODEL_TREE_CLASS)
| python | {
"resource": ""
} |
q270736 | redirects_handler | test | def redirects_handler(*args, **kwargs):
"""Fixes Admin contrib redirects compatibility problems
introduced in Django 1.4 by url handling changes.
"""
path = args[0].path
shift = '../'
if 'delete' in path:
# Weird enough 'delete' is not handled by TreeItemAdmin::response_change().
shift += '../'
elif 'history' in | python | {
"resource": ""
} |
q270737 | TreeItemAdmin._redirect | test | def _redirect(self, request, response):
"""Generic redirect for item editor."""
if '_addanother' in request.POST:
return HttpResponseRedirect('../item_add/')
elif '_save' in request.POST:
| python | {
"resource": ""
} |
q270738 | TreeItemAdmin.response_add | test | def response_add(self, request, obj, post_url_continue=None, **kwargs):
"""Redirects to the appropriate items' 'continue' page on item add.
As we administer tree items within tree itself, we
should make some changes to redirection process.
"""
if | python | {
"resource": ""
} |
q270739 | TreeItemAdmin.response_change | test | def response_change(self, request, obj, **kwargs):
"""Redirects to the appropriate items' 'add' page on item change.
As we administer tree items within tree itself, we
should make some changes | python | {
"resource": ""
} |
q270740 | TreeItemAdmin.get_form | test | def get_form(self, request, obj=None, **kwargs):
"""Returns modified form for TreeItem model.
'Parent' field choices are built by sitetree itself.
"""
if obj is not None and obj.parent is not None:
self.previous_parent = obj.parent
previous_parent_id = self.previous_parent.id
else:
previous_parent_id = None
my_choice_field = TreeItemChoiceField(self.tree, initial=previous_parent_id)
form = super(TreeItemAdmin, self).get_form(request, obj, **kwargs)
my_choice_field.label = form.base_fields['parent'].label
my_choice_field.help_text = form.base_fields['parent'].help_text
my_choice_field.widget = form.base_fields['parent'].widget
# Replace 'parent' TreeItem field with new appropriate one
form.base_fields['parent'] = my_choice_field
# Try to resolve all currently registered url names including those in namespaces.
if not getattr(self, 'known_url_names', False):
self.known_url_names = []
self.known_url_rules = []
resolver = get_resolver(get_urlconf())
for ns, (url_prefix, ns_resolver) in resolver.namespace_dict.items():
if ns != 'admin': | python | {
"resource": ""
} |
q270741 | TreeItemAdmin.get_tree | test | def get_tree(self, request, tree_id, item_id=None):
"""Fetches Tree for current or given TreeItem."""
if tree_id is None:
tree_id = self.get_object(request, item_id).tree_id
self.tree = MODEL_TREE_CLASS._default_manager.get(pk=tree_id)
| python | {
"resource": ""
} |
q270742 | TreeItemAdmin.item_move | test | def item_move(self, request, tree_id, item_id, direction):
"""Moves item up or down by swapping 'sort_order' field values of neighboring items."""
current_item = MODEL_TREE_ITEM_CLASS._default_manager.get(pk=item_id)
if direction == 'up':
sort_order = 'sort_order'
else:
sort_order = '-sort_order'
siblings = MODEL_TREE_ITEM_CLASS._default_manager.filter(
parent=current_item.parent,
| python | {
"resource": ""
} |
q270743 | TreeItemAdmin.save_model | test | def save_model(self, request, obj, form, change):
"""Saves TreeItem model under certain Tree.
Handles item's parent assignment exception.
"""
if change:
# No, you're not allowed to make item parent of itself
if obj.parent is not None and obj.parent.id == obj.id:
| python | {
"resource": ""
} |
q270744 | TreeAdmin.get_urls | test | def get_urls(self):
"""Manages not only TreeAdmin URLs but also TreeItemAdmin URLs."""
urls = super(TreeAdmin, self).get_urls()
prefix_change = 'change/' if DJANGO_POST_19 else ''
sitetree_urls = [
url(r'^change/$', redirects_handler, name=get_tree_item_url_name('changelist')),
url(r'^((?P<tree_id>\d+)/)?%sitem_add/$' % prefix_change,
self.admin_site.admin_view(self.tree_admin.item_add), name=get_tree_item_url_name('add')),
url(r'^(?P<tree_id>\d+)/%sitem_(?P<item_id>\d+)/$' % prefix_change,
self.admin_site.admin_view(self.tree_admin.item_edit), name=get_tree_item_url_name('change')),
url(r'^%sitem_(?P<item_id>\d+)/$' % prefix_change,
self.admin_site.admin_view(self.tree_admin.item_edit), name=get_tree_item_url_name('change')),
url(r'^((?P<tree_id>\d+)/)?%sitem_(?P<item_id>\d+)/delete/$' % prefix_change,
self.admin_site.admin_view(self.tree_admin.item_delete), name=get_tree_item_url_name('delete')),
url(r'^((?P<tree_id>\d+)/)?%sitem_(?P<item_id>\d+)/history/$' % prefix_change,
| python | {
"resource": ""
} |
q270745 | TreeAdmin.dump_view | test | def dump_view(cls, request):
"""Dumps sitetrees with items using django-smuggler.
:param request:
| python | {
"resource": ""
} |
q270746 | tree | test | def tree(alias, title='', items=None, **kwargs):
"""Dynamically creates and returns a sitetree.
:param str|unicode alias:
:param str|unicode title:
:param iterable items: dynamic sitetree items objects created by `item` function.
:param kwargs: Additional arguments to pass to tree item initializer.
:rtype: TreeBase
| python | {
"resource": ""
} |
q270747 | item | test | def item(
title, url, children=None, url_as_pattern=True, hint='', alias='', description='',
in_menu=True, in_breadcrumbs=True, in_sitetree=True,
access_loggedin=False, access_guest=False,
access_by_perms=None, perms_mode_all=True, **kwargs):
"""Dynamically creates and returns a sitetree item object.
:param str|unicode title:
:param str|unicode url:
:param list, set children: a list of children for tree item. Children should also be created by `item` function.
:param bool url_as_pattern: consider URL as a name of a named URL
:param str|unicode hint: hints are usually shown to users
:param str|unicode alias: item name to address it from templates
:param str|unicode description: additional information on item (usually is not shown to users)
:param bool in_menu: show this item in menus
:param bool in_breadcrumbs: show this item in breadcrumbs
:param bool in_sitetree: show this item in sitetrees
:param bool access_loggedin: show item to logged in users only
:param bool access_guest: show item to guest users only
:param list|str||unicode|int, Permission access_by_perms: restrict access to users with these permissions.
This can be set to one or a list of permission names, IDs or Permission instances.
Permission names are more portable and should be in a form `<app_label>.<perm_codename>`, e.g.:
my_app.allow_save
:param bool perms_mode_all: permissions set interpretation rule:
True - user should have all the permissions;
False - user should have any of chosen permissions.
:rtype: TreeItemBase
"""
item_obj = get_tree_item_model()(
title=title, url=url, urlaspattern=url_as_pattern,
hint=hint, alias=alias, description=description, inmenu=in_menu,
insitetree=in_sitetree, inbreadcrumbs=in_breadcrumbs,
access_loggedin=access_loggedin, access_guest=access_guest,
**kwargs)
item_obj.id = generate_id_for(item_obj)
item_obj.is_dynamic = True
item_obj.dynamic_children = []
cleaned_permissions = []
if access_by_perms:
# Make permissions a list if currently a single object
if not isinstance(access_by_perms, list):
access_by_perms = [access_by_perms]
for perm in access_by_perms:
if isinstance(perm, six.string_types):
# Get permission object from string
try:
| python | {
"resource": ""
} |
q270748 | import_app_sitetree_module | test | def import_app_sitetree_module(app):
"""Imports sitetree module from a given app.
:param str|unicode app: Application name
:return: module|None
"""
module_name = settings.APP_MODULE_NAME
| python | {
"resource": ""
} |
q270749 | get_model_class | test | def get_model_class(settings_entry_name):
"""Returns a certain sitetree model as defined in the project settings.
:param str|unicode settings_entry_name:
:rtype: TreeItemBase|TreeBase
"""
app_name, model_name = get_app_n_model(settings_entry_name)
try:
model = apps_get_model(app_name, model_name)
except (LookupError, ValueError):
model = None | python | {
"resource": ""
} |
q270750 | Config.from_mapping | test | def from_mapping(
cls: Type["Config"], mapping: Optional[Mapping[str, Any]] = None, **kwargs: Any
) -> "Config":
"""Create a configuration from a mapping.
This allows either a mapping to be directly passed or as
keyword arguments, for example,
.. code-block:: python
config = {'keep_alive_timeout': 10}
Config.from_mapping(config)
Config.form_mapping(keep_alive_timeout=10)
Arguments:
mapping: Optionally a mapping object.
kwargs: Optionally a collection of keyword arguments to
| python | {
"resource": ""
} |
q270751 | Config.from_pyfile | test | def from_pyfile(cls: Type["Config"], filename: FilePath) -> "Config":
"""Create a configuration from a Python file.
.. code-block:: python
Config.from_pyfile('hypercorn_config.py')
Arguments:
filename: The filename which gives the path to the file.
"""
| python | {
"resource": ""
} |
q270752 | Config.from_toml | test | def from_toml(cls: Type["Config"], filename: FilePath) -> "Config":
"""Load the configuration values from a TOML formatted file.
This allows configuration to be loaded as so
.. code-block:: python
Config.from_toml('config.toml')
Arguments:
| python | {
"resource": ""
} |
q270753 | Config.from_object | test | def from_object(cls: Type["Config"], instance: Union[object, str]) -> "Config":
"""Create a configuration from a Python object.
This can be used to reference modules or objects within
modules for example,
.. code-block:: python
Config.from_object('module')
Config.from_object('module.instance')
from module import instance
Config.from_object(instance)
are valid.
Arguments:
instance: Either a str referencing a python object or the
object itself.
"""
if isinstance(instance, str):
try:
path, config = instance.rsplit(".", 1)
except ValueError:
path = instance
instance = | python | {
"resource": ""
} |
q270754 | create_attrs_for_span | test | def create_attrs_for_span(
sample_rate=100.0,
trace_id=None,
span_id=None,
use_128bit_trace_id=False,
):
"""Creates a set of zipkin attributes for a span.
:param sample_rate: Float between 0.0 and 100.0 to determine sampling rate
:type sample_rate: float
:param trace_id: Optional 16-character hex string representing a trace_id.
If this is None, a random trace_id will be generated.
:type trace_id: str
:param span_id: Optional 16-character hex string representing a span_id.
If this is None, a random span_id will be generated.
:type span_id: str
:param use_128bit_trace_id: If true, generate 128-bit trace_ids
:type use_128bit_trace_id: boolean
"""
# Calculate if this trace is sampled based on the sample rate | python | {
"resource": ""
} |
q270755 | create_http_headers_for_new_span | test | def create_http_headers_for_new_span(context_stack=None, tracer=None):
"""
Generate the headers for a new zipkin span.
.. note::
If the method is not called from within a zipkin_trace context,
empty dict will be returned back.
:returns: dict containing (X-B3-TraceId, X-B3-SpanId, X-B3-ParentSpanId,
X-B3-Flags and X-B3-Sampled) keys OR an empty dict.
"""
if tracer:
zipkin_attrs = tracer.get_zipkin_attrs()
elif context_stack:
zipkin_attrs = context_stack.get()
else:
zipkin_attrs = get_default_tracer().get_zipkin_attrs()
if not zipkin_attrs:
| python | {
"resource": ""
} |
q270756 | zipkin_span._get_current_context | test | def _get_current_context(self):
"""Returns the current ZipkinAttrs and generates new ones if needed.
:returns: (report_root_timestamp, zipkin_attrs)
:rtype: (bool, ZipkinAttrs)
"""
# This check is technically not necessary since only root spans will have
# sample_rate, zipkin_attrs or a transport set. But it helps making the
# code clearer by separating the logic for a root span from the one for a
# child span.
if self._is_local_root_span:
# If sample_rate is set, we need to (re)generate a trace context.
# If zipkin_attrs (trace context) were passed in as argument there are
# 2 possibilities:
# is_sampled = False --> we keep the same trace_id but re-roll the dice
# for is_sampled.
# is_sampled = True --> we don't want to stop sampling halfway through
# a sampled trace, so we do nothing.
# If no zipkin_attrs were passed in, we generate new ones and start a
# new trace.
if self.sample_rate is not None:
# If this trace is not sampled, we re-roll the dice.
if self.zipkin_attrs_override and \
not self.zipkin_attrs_override.is_sampled:
# This will be the root span of the trace, so we should
# set timestamp and duration.
return True, create_attrs_for_span(
sample_rate=self.sample_rate,
trace_id=self.zipkin_attrs_override.trace_id,
)
# If zipkin_attrs_override was not passed in, we simply generate
# new zipkin_attrs to start a new trace.
elif not self.zipkin_attrs_override:
return True, create_attrs_for_span(
sample_rate=self.sample_rate,
use_128bit_trace_id=self.use_128bit_trace_id,
| python | {
"resource": ""
} |
q270757 | zipkin_span.start | test | def start(self):
"""Enter the new span context. All annotations logged inside this
context will be attributed to this span. All new spans generated
inside this context will have this span as their parent.
In the unsampled case, this context still generates new span IDs and
pushes them onto the threadlocal stack, so downstream services calls
made will pass the correct headers. However, the logging handler is
never attached in the unsampled case, so the spans are never logged.
"""
self.do_pop_attrs = False
report_root_timestamp, self.zipkin_attrs = self._get_current_context()
# If zipkin_attrs are not set up by now, that means this span is not
# configured to perform logging itself, and it's not in an existing
# Zipkin trace. That means there's nothing else to do and it can exit
# early.
if not self.zipkin_attrs:
return self
self.get_tracer().push_zipkin_attrs(self.zipkin_attrs)
self.do_pop_attrs = True
self.start_timestamp = time.time()
if self._is_local_root_span:
# Don't set up any logging if we're not sampling
if not self.zipkin_attrs.is_sampled and not self.firehose_handler:
return self
# If transport is already configured don't override it. Doing so would
# cause all previously recorded spans to never be emitted as exiting
# the inner logging context will reset transport_configured to False.
| python | {
"resource": ""
} |
q270758 | zipkin_span.stop | test | def stop(self, _exc_type=None, _exc_value=None, _exc_traceback=None):
"""Exit the span context. Zipkin attrs are pushed onto the
threadlocal stack regardless of sampling, so they always need to be
popped off. The actual logging of spans depends on sampling and that
the logging was correctly set up.
"""
if self.do_pop_attrs:
self.get_tracer().pop_zipkin_attrs()
# If no transport is configured, there's no reason to create a new Span.
# This also helps avoiding memory leaks since without a transport nothing
# would pull spans out of get_tracer().
if not self.get_tracer().is_transport_configured():
return
# Add the error annotation if an exception occurred
if any((_exc_type, _exc_value, _exc_traceback)):
error_msg = u'{0}: {1}'.format(_exc_type.__name__, _exc_value)
self.update_binary_annotations({
ERROR_KEY: error_msg,
})
# Logging context is only initialized for "root" spans of the local
# process (i.e. this zipkin_span not inside of any other local
# zipkin_spans)
if self.logging_context:
try:
self.logging_context.stop()
except Exception as ex:
err_msg = 'Error emitting zipkin trace. {}'.format(
repr(ex),
)
log.error(err_msg)
finally:
self.logging_context = None
self.get_tracer().clear()
self.get_tracer().set_transport_configured(configured=False)
return
# If we've gotten here, that means that this span is a child span of
# this context's root span (i.e. it's a zipkin_span inside another
| python | {
"resource": ""
} |
q270759 | zipkin_span.update_binary_annotations | test | def update_binary_annotations(self, extra_annotations):
"""Updates the binary annotations for the current span."""
if not self.logging_context:
# This is not the root span, so binary annotations will be added
# to the log handler when this span context exits.
self.binary_annotations.update(extra_annotations)
| python | {
"resource": ""
} |
q270760 | zipkin_span.add_sa_binary_annotation | test | def add_sa_binary_annotation(
self,
port=0,
service_name='unknown',
host='127.0.0.1',
):
"""Adds a 'sa' binary annotation to the current span.
'sa' binary annotations are useful for situations where you need to log
where a request is going but the destination doesn't support zipkin.
Note that the span must have 'cs'/'cr' annotations.
:param port: The port number of the destination
:type port: int
:param service_name: The name of the destination service
:type service_name: str
:param host: Host address of the destination
:type host: str
"""
if self.kind != Kind.CLIENT:
# TODO: trying to set a sa binary annotation for a non-client span
# should result in a logged error
return
remote_endpoint = create_endpoint(
port=port,
service_name=service_name,
| python | {
"resource": ""
} |
q270761 | zipkin_span.override_span_name | test | def override_span_name(self, name):
"""Overrides the current span name.
This is useful if you don't know the span name yet when you create the
zipkin_span object. i.e. pyramid_zipkin doesn't know which route the
request matched until the function wrapped by the context manager
completes.
| python | {
"resource": ""
} |
q270762 | create_endpoint | test | def create_endpoint(port=None, service_name=None, host=None, use_defaults=True):
"""Creates a new Endpoint object.
:param port: TCP/UDP port. Defaults to 0.
:type port: int
:param service_name: service name as a str. Defaults to 'unknown'.
:type service_name: str
:param host: ipv4 or ipv6 address of the host. Defaults to the
current host ip.
:type host: str
:param use_defaults: whether to use defaults.
:type use_defaults: bool
:returns: zipkin Endpoint object
"""
if use_defaults:
if port is None:
port = 0
if service_name is None:
service_name = 'unknown'
if host is None:
try:
host = socket.gethostbyname(socket.gethostname())
except socket.gaierror:
host = '127.0.0.1'
ipv4 = None
ipv6 = None
if host:
# Check ipv4 or ipv6.
| python | {
"resource": ""
} |
q270763 | copy_endpoint_with_new_service_name | test | def copy_endpoint_with_new_service_name(endpoint, new_service_name):
"""Creates a copy of a given endpoint with a new service name.
:param endpoint: existing Endpoint object
:type endpoint: Endpoint
| python | {
"resource": ""
} |
q270764 | Span.build_v1_span | test | def build_v1_span(self):
"""Builds and returns a V1 Span.
:return: newly generated _V1Span
:rtype: _V1Span
"""
# We are simulating a full two-part span locally, so set cs=sr and ss=cr
full_annotations = OrderedDict([
('cs', self.timestamp),
('sr', self.timestamp),
('ss', self.timestamp + self.duration),
('cr', self.timestamp + self.duration),
])
if self.kind != Kind.LOCAL:
# If kind is not LOCAL, then we only want client or
# server side annotations.
for ann in _DROP_ANNOTATIONS_BY_KIND[self.kind]:
del full_annotations[ann]
# Add user-defined annotations. We write them in full_annotations
# instead of the opposite so that user annotations will override | python | {
"resource": ""
} |
q270765 | encode_pb_list | test | def encode_pb_list(pb_spans):
"""Encode list of protobuf Spans to binary.
:param pb_spans: list of protobuf Spans.
:type pb_spans: list of zipkin_pb2.Span
:return: encoded list.
:rtype: bytes
| python | {
"resource": ""
} |
q270766 | create_protobuf_span | test | def create_protobuf_span(span):
"""Converts a py_zipkin Span in a protobuf Span.
:param span: py_zipkin Span to convert.
:type span: py_zipkin.encoding.Span
:return: protobuf's Span
:rtype: zipkin_pb2.Span
"""
# Protobuf's composite types (i.e. Span's local_endpoint) are immutable.
# So we can't create a zipkin_pb2.Span here and then set the appropriate
# fields since `pb_span.local_endpoint = zipkin_pb2.Endpoint` fails.
# Instead we just create the kwargs and pass them in to the Span constructor.
pb_kwargs = {}
pb_kwargs['trace_id'] = _hex_to_bytes(span.trace_id)
if span.parent_id:
pb_kwargs['parent_id'] = _hex_to_bytes(span.parent_id)
pb_kwargs['id'] = _hex_to_bytes(span.span_id)
pb_kind = _get_protobuf_kind(span.kind)
if pb_kind:
pb_kwargs['kind'] = pb_kind
if span.name:
pb_kwargs['name'] = span.name
if span.timestamp:
pb_kwargs['timestamp'] = int(span.timestamp * 1000 * | python | {
"resource": ""
} |
q270767 | _hex_to_bytes | test | def _hex_to_bytes(hex_id):
"""Encodes to hexadecimal ids to big-endian binary.
:param hex_id: hexadecimal id to encode.
:type hex_id: str
:return: binary representation.
:type: bytes
"""
if len(hex_id) <= 16:
int_id = unsigned_hex_to_signed_int(hex_id)
return struct.pack('>q', int_id)
else:
# There's no 16-bytes encoding in | python | {
"resource": ""
} |
q270768 | _get_protobuf_kind | test | def _get_protobuf_kind(kind):
"""Converts py_zipkin's Kind to Protobuf's Kind.
:param kind: py_zipkin's Kind.
:type kind: py_zipkin.Kind
:return: correcponding protobuf's kind value.
:rtype: zipkin_pb2.Span.Kind
"""
if kind == Kind.CLIENT:
return zipkin_pb2.Span.CLIENT
elif kind == Kind.SERVER:
| python | {
"resource": ""
} |
q270769 | _convert_endpoint | test | def _convert_endpoint(endpoint):
"""Converts py_zipkin's Endpoint to Protobuf's Endpoint.
:param endpoint: py_zipkins' endpoint to convert.
:type endpoint: py_zipkin.encoding.Endpoint
:return: corresponding protobuf's endpoint.
:rtype: zipkin_pb2.Endpoint
"""
pb_endpoint = zipkin_pb2.Endpoint()
if endpoint.service_name:
pb_endpoint.service_name = endpoint.service_name
if endpoint.port and endpoint.port != 0:
| python | {
"resource": ""
} |
q270770 | _convert_annotations | test | def _convert_annotations(annotations):
"""Converts py_zipkin's annotations dict to protobuf.
:param annotations: annotations dict.
:type annotations: dict
:return: corresponding protobuf's list of annotations.
:rtype: list
"""
pb_annotations = []
for value, ts in annotations.items():
| python | {
"resource": ""
} |
q270771 | create_annotation | test | def create_annotation(timestamp, value, host):
"""
Create a zipkin annotation object
:param timestamp: timestamp of when the annotation occured in microseconds
:param value: name of the annotation, such as 'sr'
| python | {
"resource": ""
} |
q270772 | create_binary_annotation | test | def create_binary_annotation(key, value, annotation_type, host):
"""
Create a zipkin binary annotation object
:param key: name of the annotation, such as 'http.uri'
:param value: value of the annotation, such as | python | {
"resource": ""
} |
q270773 | create_endpoint | test | def create_endpoint(port=0, service_name='unknown', ipv4=None, ipv6=None):
"""Create a zipkin Endpoint object.
An Endpoint object holds information about the network context of a span.
:param port: int value of the port. Defaults to 0
:param service_name: service name as a str. Defaults to 'unknown'
:param ipv4: ipv4 host address
:param ipv6: ipv6 host address
:returns: thrift Endpoint object
"""
ipv4_int = 0
ipv6_binary = None
# Convert ip address to network byte order
if ipv4:
ipv4_int = struct.unpack('!i', socket.inet_pton(socket.AF_INET, ipv4))[0]
if ipv6:
ipv6_binary = socket.inet_pton(socket.AF_INET6, ipv6)
| python | {
"resource": ""
} |
q270774 | copy_endpoint_with_new_service_name | test | def copy_endpoint_with_new_service_name(endpoint, service_name):
"""Copies a copy of a given endpoint with a new service name.
This should be very fast, on the order of several microseconds.
:param endpoint: existing zipkin_core.Endpoint object
:param service_name: str of | python | {
"resource": ""
} |
q270775 | annotation_list_builder | test | def annotation_list_builder(annotations, host):
"""
Reformat annotations dict to return list of corresponding zipkin_core objects.
:param annotations: dict containing key as annotation name,
value being timestamp in seconds(float).
:type host: :class:`zipkin_core.Endpoint`
:returns: a list | python | {
"resource": ""
} |
q270776 | binary_annotation_list_builder | test | def binary_annotation_list_builder(binary_annotations, host):
"""
Reformat binary annotations dict to return list of zipkin_core objects. The
value of the binary annotations MUST be in string format.
:param binary_annotations: dict with key, value being the name and value
of the binary annotation being logged.
:type host: :class:`zipkin_core.Endpoint`
:returns: a | python | {
"resource": ""
} |
q270777 | create_span | test | def create_span(
span_id,
parent_span_id,
trace_id,
span_name,
annotations,
binary_annotations,
timestamp_s,
duration_s,
):
"""Takes a bunch of span attributes and returns a thriftpy2 representation
of the span. Timestamps passed in are in seconds, they're converted to
microseconds before thrift encoding.
"""
# Check if trace_id is 128-bit. If so, record trace_id_high separately.
trace_id_length = len(trace_id)
trace_id_high = None
if trace_id_length > 16:
assert trace_id_length == 32
trace_id, trace_id_high = trace_id[16:], trace_id[:16]
if trace_id_high:
trace_id_high = unsigned_hex_to_signed_int(trace_id_high)
span_dict = {
'trace_id': unsigned_hex_to_signed_int(trace_id),
'name': span_name, | python | {
"resource": ""
} |
q270778 | span_to_bytes | test | def span_to_bytes(thrift_span):
"""
Returns a TBinaryProtocol encoded Thrift span.
:param thrift_span: thrift object to encode.
:returns: thrift object in TBinaryProtocol format bytes.
"""
| python | {
"resource": ""
} |
q270779 | encode_bytes_list | test | def encode_bytes_list(binary_thrift_obj_list): # pragma: no cover
"""
Returns a TBinaryProtocol encoded list of Thrift objects.
:param binary_thrift_obj_list: list of TBinaryProtocol objects to encode.
:returns: bynary object representing the encoded list.
""" | python | {
"resource": ""
} |
q270780 | detect_span_version_and_encoding | test | def detect_span_version_and_encoding(message):
"""Returns the span type and encoding for the message provided.
The logic in this function is a Python port of
https://github.com/openzipkin/zipkin/blob/master/zipkin/src/main/java/zipkin/internal/DetectingSpanDecoder.java
:param message: span to perform operations on.
:type message: byte array
:returns: span encoding.
:rtype: Encoding
"""
# In case message is sent in as non-bytearray format,
# safeguard convert to bytearray before handling
if isinstance(message, six.string_types):
# Even six.b is not enough to handle the py2/3 difference since
# it uses latin-1 as default encoding and not utf-8.
if six.PY2:
message = six.b(message) # pragma: no cover
else:
message = message.encode('utf-8') # pragma: no cover
if len(message) < 2:
raise ZipkinError("Invalid span format. Message too short.")
# Check for binary format
if six.byte2int(message) <= 16:
if six.byte2int(message) == 10 and six.byte2int(message[1:2]) != 0:
return Encoding.V2_PROTO3
return Encoding.V1_THRIFT
str_msg = message.decode('utf-8')
# JSON case for list of spans
if str_msg[0] == '[':
span_list = json.loads(str_msg)
if len(span_list) > 0:
# Assumption: All spans in | python | {
"resource": ""
} |
q270781 | convert_spans | test | def convert_spans(spans, output_encoding, input_encoding=None):
"""Converts encoded spans to a different encoding.
param spans: encoded input spans.
type spans: byte array
param output_encoding: desired output encoding.
type output_encoding: Encoding
param input_encoding: optional input encoding. If this is not specified, it'll
try to understand the encoding automatically by inspecting the input spans.
type input_encoding: Encoding
| python | {
"resource": ""
} |
q270782 | push_zipkin_attrs | test | def push_zipkin_attrs(zipkin_attr):
"""Stores the zipkin attributes to thread local.
.. deprecated::
Use the Tracer interface which offers better multi-threading support.
push_zipkin_attrs will be removed in version 1.0.
:param zipkin_attr: tuple containing zipkin related attrs
:type zipkin_attr: :class:`zipkin.ZipkinAttrs`
"""
from py_zipkin.storage import ThreadLocalStack
| python | {
"resource": ""
} |
q270783 | _V1ThriftEncoder.encode_span | test | def encode_span(self, v2_span):
"""Encodes the current span to thrift."""
span = v2_span.build_v1_span()
thrift_endpoint = thrift.create_endpoint(
span.endpoint.port,
span.endpoint.service_name,
span.endpoint.ipv4,
span.endpoint.ipv6,
)
thrift_annotations = thrift.annotation_list_builder(
span.annotations,
thrift_endpoint,
)
thrift_binary_annotations = thrift.binary_annotation_list_builder(
| python | {
"resource": ""
} |
q270784 | _BaseJSONEncoder._create_json_endpoint | test | def _create_json_endpoint(self, endpoint, is_v1):
"""Converts an Endpoint to a JSON endpoint dict.
:param endpoint: endpoint object to convert.
:type endpoint: Endpoint
:param is_v1: whether we're serializing a v1 span. This is needed since
in v1 some fields default to an empty string rather than being
dropped if they're not set.
:type is_v1: bool
:return: dict representing a JSON endpoint.
:rtype: dict
"""
json_endpoint = {}
if endpoint.service_name:
json_endpoint['serviceName'] = endpoint.service_name
| python | {
"resource": ""
} |
q270785 | _V2ProtobufEncoder.encode_span | test | def encode_span(self, span):
"""Encodes a single span to protobuf."""
if not protobuf.installed():
raise ZipkinError(
'protobuf encoding requires installing the protobuf\'s extra '
| python | {
"resource": ""
} |
q270786 | _V1ThriftDecoder.decode_spans | test | def decode_spans(self, spans):
"""Decodes an encoded list of spans.
:param spans: encoded list of spans
:type spans: bytes
:return: list of spans
:rtype: list of Span
"""
decoded_spans = []
transport = TMemoryBuffer(spans) | python | {
"resource": ""
} |
q270787 | _V1ThriftDecoder._convert_from_thrift_endpoint | test | def _convert_from_thrift_endpoint(self, thrift_endpoint):
"""Accepts a thrift decoded endpoint and converts it to an Endpoint.
:param thrift_endpoint: thrift encoded endpoint
:type thrift_endpoint: thrift endpoint
:returns: decoded endpoint
:rtype: Encoding
"""
ipv4 = None
ipv6 = None
port = struct.unpack('H', struct.pack('h', thrift_endpoint.port))[0]
if thrift_endpoint.ipv4 != 0:
ipv4 = socket.inet_ntop(
socket.AF_INET,
| python | {
"resource": ""
} |
q270788 | _V1ThriftDecoder._decode_thrift_annotations | test | def _decode_thrift_annotations(self, thrift_annotations):
"""Accepts a thrift annotation and converts it to a v1 annotation.
:param thrift_annotations: list of thrift annotations.
:type thrift_annotations: list of zipkin_core.Span.Annotation
:returns: (annotations, local_endpoint, kind)
"""
local_endpoint = None
kind = Kind.LOCAL
all_annotations = {}
timestamp = None
duration = None
for thrift_annotation in thrift_annotations:
all_annotations[thrift_annotation.value] = thrift_annotation.timestamp
if thrift_annotation.host:
local_endpoint = self._convert_from_thrift_endpoint(
thrift_annotation.host,
)
if 'cs' in all_annotations and 'sr' not in all_annotations:
kind = Kind.CLIENT
timestamp = all_annotations['cs']
duration = all_annotations['cr'] - all_annotations['cs']
| python | {
"resource": ""
} |
q270789 | _V1ThriftDecoder._convert_from_thrift_binary_annotations | test | def _convert_from_thrift_binary_annotations(self, thrift_binary_annotations):
"""Accepts a thrift decoded binary annotation and converts it
to a v1 binary annotation.
"""
tags = {}
local_endpoint = None
remote_endpoint = None
for binary_annotation in thrift_binary_annotations:
if binary_annotation.key == 'sa':
remote_endpoint = self._convert_from_thrift_endpoint(
thrift_endpoint=binary_annotation.host,
)
else:
key = binary_annotation.key
annotation_type = binary_annotation.annotation_type
value = binary_annotation.value
if annotation_type == zipkin_core.AnnotationType.BOOL:
tags[key] = "true" if value == 1 else "false"
elif annotation_type == zipkin_core.AnnotationType.STRING:
tags[key] = str(value)
| python | {
"resource": ""
} |
q270790 | _V1ThriftDecoder._decode_thrift_span | test | def _decode_thrift_span(self, thrift_span):
"""Decodes a thrift span.
:param thrift_span: thrift span
:type thrift_span: thrift Span object
:returns: span builder representing this span
:rtype: Span
"""
parent_id = None
local_endpoint = None
annotations = {}
tags = {}
kind = Kind.LOCAL
remote_endpoint = None
timestamp = None
duration = None
if thrift_span.parent_id:
parent_id = self._convert_unsigned_long_to_lower_hex(
thrift_span.parent_id,
)
if thrift_span.annotations:
annotations, local_endpoint, kind, timestamp, duration = \
self._decode_thrift_annotations(thrift_span.annotations)
if thrift_span.binary_annotations:
tags, local_endpoint, remote_endpoint = \
self._convert_from_thrift_binary_annotations(
thrift_span.binary_annotations,
)
trace_id = self._convert_trace_id_to_string(
thrift_span.trace_id,
thrift_span.trace_id_high,
| python | {
"resource": ""
} |
q270791 | _V1ThriftDecoder._convert_trace_id_to_string | test | def _convert_trace_id_to_string(self, trace_id, trace_id_high=None):
"""
Converts the provided traceId hex value with optional high bits
to a string.
:param trace_id: the value of the trace ID
:type trace_id: int
:param trace_id_high: the high bits of the trace ID
:type trace_id: int
:returns: trace_id_high + trace_id as a string
"""
if trace_id_high is not None:
result = bytearray(32)
| python | {
"resource": ""
} |
q270792 | _V1ThriftDecoder._convert_unsigned_long_to_lower_hex | test | def _convert_unsigned_long_to_lower_hex(self, value):
"""
Converts the provided unsigned long value to a hex string.
:param value: the value to convert
:type value: unsigned long
:returns: value as a hex string
| python | {
"resource": ""
} |
q270793 | _V1ThriftDecoder._write_hex_long | test | def _write_hex_long(self, data, pos, value):
"""
Writes an unsigned long value across a byte array.
:param data: the buffer to write the value to
:type data: bytearray
:param pos: the starting position
:type pos: int
:param value: the value to write
:type value: unsigned long
"""
| python | {
"resource": ""
} |
q270794 | date_fixup_pre_processor | test | def date_fixup_pre_processor(transactions, tag, tag_dict, *args):
"""
Replace illegal February 29, 30 dates with the last day of February.
German banks use a variant of the 30/360 interest rate calculation,
where each month has always 30 days even February. Python's datetime
module won't accept such dates.
"""
if tag_dict['month'] == '02':
| python | {
"resource": ""
} |
q270795 | mBank_set_transaction_code | test | def mBank_set_transaction_code(transactions, tag, tag_dict, *args):
"""
mBank Collect uses transaction code 911 to distinguish icoming mass
payments transactions, adding transaction_code may be helpful in further
processing | python | {
"resource": ""
} |
q270796 | mBank_set_iph_id | test | def mBank_set_iph_id(transactions, tag, tag_dict, *args):
"""
mBank Collect uses ID IPH to distinguish between virtual accounts,
adding iph_id may be helpful in further processing
"""
matches = | python | {
"resource": ""
} |
q270797 | mBank_set_tnr | test | def mBank_set_tnr(transactions, tag, tag_dict, *args):
"""
mBank Collect states TNR in transaction details as unique id for
transactions, that may be used to identify the same transactions in
different statement files eg. | python | {
"resource": ""
} |
q270798 | Transactions.parse | test | def parse(self, data):
'''Parses mt940 data, expects a string with data
Args:
data (str): The MT940 data
Returns: :py:class:`list` of :py:class:`Transaction`
'''
# Remove extraneous whitespace and such
data = '\n'.join(self.strip(data.split('\n')))
# The pattern is a bit annoying to match by regex, even with a greedy
# match it's difficult to get both the beginning and the end so we're
# working around it in a safer way to get everything.
tag_re = re.compile(
r'^:\n?(?P<full_tag>(?P<tag>[0-9]{2}|NS)(?P<sub_tag>[A-Z])?):',
re.MULTILINE)
matches = list(tag_re.finditer(data))
# identify valid matches
valid_matches = list(self.sanatize_tag_id_matches(matches))
for i, match in enumerate(valid_matches):
tag_id = self.normalize_tag_id(match.group('tag'))
# get tag instance corresponding to tag id
tag = self.tags.get(match.group('full_tag')) \
or self.tags[tag_id]
# Nice trick to get all the text that is part of this tag, python
# regex matches have a `end()` and `start()` to indicate the start
# and end index of the match.
if valid_matches[i + 1:]:
tag_data = \
data[match.end():valid_matches[i + 1].start()].strip()
else:
tag_data = data[match.end():].strip()
tag_dict = tag.parse(self, tag_data)
# Preprocess data before creating the object
for processor in self.processors.get('pre_%s' % tag.slug, []):
tag_dict = processor(self, tag, tag_dict)
result = tag(self, tag_dict)
# Postprocess the object
for processor in self.processors.get('post_%s' % tag.slug, []):
result = processor(self, tag, tag_dict, result)
# Creating a new transaction for :20: and :61: tags allows the
# tags from :20: to :61: to be captured as part of the transaction.
if isinstance(tag, mt940.tags.Statement):
# Transactions only get a Transaction Reference Code ID from | python | {
"resource": ""
} |
q270799 | parse | test | def parse(src, encoding=None):
'''
Parses mt940 data and returns transactions object
:param src: file handler to read, filename to read or raw data as string
:return: Collection of transactions
:rtype: Transactions
'''
def safe_is_file(filename):
try:
return os.path.isfile(src)
except ValueError: # pragma: no cover
return False
if hasattr(src, 'read'): # pragma: no branch
data = src.read()
elif safe_is_file(src):
with | python | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.