INSTRUCTION stringlengths 1 8.43k | RESPONSE stringlengths 75 104k |
|---|---|
Registers a hook callable to process tree items right before they are passed to templates. | 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... |
Registers dynamic trees to be available for sitetree runtime. Expects trees to be an iterable with structures created with compose_dynamic_tree (). | def register_dynamic_trees(trees, *args, **kwargs):
"""Registers dynamic trees to be available for `sitetree` runtime.
Expects `trees` to be an iterable with structures created with `compose_dynamic_tree()`.
Example::
register_dynamic_trees(
# Get all the trees from `my_app`.
... |
Returns a structure describing a dynamic sitetree. utils The structure can be built from various sources | 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... |
Initializes local cache from Django cache. | 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 = cache.get(
'sitetrees', {'sitetrees': {}, 'parents': {}, 'items_by_ids': {}, 'tree_aliases': {}}) |
Empties cached sitetree data. | def empty(self, **kwargs):
"""Empties cached sitetree data."""
cache.delete('sitetrees')
cache.delete('sitetrees_reset')
kwargs.get('init', True) and self.init() |
Returns cache entry parameter value by its name. | def get_entry(self, entry_name, key):
"""Returns cache entry parameter value by its name.
:param str|unicode entry_name:
:param key:
:return:
"""
return self.cache[entry_name].get(key, False) |
Updates cache entry parameter with new data. | 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:
"""
if key not in self.cache[entry_name]:
self.cache[entry_name][key] = {}
self.cache[entry... |
Replaces entire cache entry parameter data by its name with new data. | 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:
:param key:
:param value:
"""
self.cache[entry_name][key] = value |
Initializes sitetree to handle new request. | def init(self, context):
"""Initializes sitetree to handle new request.
:param Context|None context:
"""
self.cache = Cache()
self.current_page_context = context
self.current_request = context.get('request', None) if context else None
self.current_lang = get_lang... |
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. | 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
... |
Attaches dynamic sitetrees items registered with register_dynamic_trees () to an initial ( source ) items list. | def attach_dynamic_tree_items(tree_alias, src_tree_items):
"""Attaches dynamic sitetrees items registered with `register_dynamic_trees()`
to an initial (source) items list.
:param str|unicode tree_alias:
:param list src_tree_items:
:rtype: list
"""
if not _DYNAMI... |
Returns boolean whether current application is Admin contrib. | 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 ... |
Gets site tree items from the given site tree. Caches result to dictionary. Returns ( tree alias tree items ) tuple. | def get_sitetree(self, alias):
"""Gets site tree items from the given site tree.
Caches result to dictionary.
Returns (tree alias, tree items) tuple.
:param str|unicode alias:
:rtype: tuple
"""
cache_ = self.cache
get_cache_entry = cache_.get_entry
... |
Calculates depth of the item in the tree. | 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(ite... |
Resolves current tree item of tree_alias tree matching current request path against URL of given tree item. | 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... |
Resolves item s URL. | 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 = con... |
Initializes sitetree in memory. | 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 = co... |
Returns an arbitrary attribute of a sitetree item resolved as current for current page. | 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
"""
... |
Returns ancestor of level deep recursively | 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:
return current_item
if depth <= 1:
... |
Builds and returns menu structure for sitetree_menu tag. | 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_... |
Applies item processing hook registered with register_item_hook () to items supplied and returns processed list. | def apply_hook(self, items, sender):
"""Applies item processing hook, registered with ``register_item_hook()``
to items supplied, and returns processed list.
Returns initial items list if no hook is registered.
:param list items:
:param str|unicode sender: menu, breadcrumbs, si... |
Checks whether a current user has an access to a certain item. | 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 = sel... |
Builds and returns breadcrumb trail structure for sitetree_breadcrumbs tag. | 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)
... |
Builds and returns tree structure for sitetree_tree tag. | 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:... |
Builds and returns site tree item children structure for sitetree_children tag. | 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:
:par... |
Returns item s children. | 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 need i18n for a tree rendered in Admin dropdown.
t... |
Updates has_children attribute for tree items inplace. | 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
"""
get_children = s... |
Filters sitetree item s children if hidden and by navigation type. | 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
... |
Climbs up the site tree to resolve root item for chosen one. | 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... |
Climbs up the site tree to mark items of current branch. | 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 = True
if hasattr(base_item,... |
Resolves name as a variable in a given context. | 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:
"""
context = context or self.current_pa... |
Parses sitetree tag parameters. | 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 "sit... |
Parses sitetree_children tag parameters. | 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.h... |
Parses sitetree_breadcrumbs tag parameters. | 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:
{% site... |
Parses sitetree_menu tag parameters. | 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:
... |
Render helper is used by template node functions to render given template with given tree items in context. | 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):
use_template = use_temp... |
Node constructor to be used in tags. | 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])
... |
Returns a URL for a given Tree admin page type. | 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:
prefix = 'admin:'
return ('%s%s_%s' % (prefix, '%s_%s' % model_nfo, page)).lower() |
Forces unregistration of tree admin class with following re - registration. | def _reregister_tree_admin():
"""Forces unregistration of tree admin class with following re-registration."""
try:
admin.site.unregister(MODEL_TREE_CLASS)
except NotRegistered:
pass
admin.site.register(MODEL_TREE_CLASS, _TREE_ADMIN()) |
Fixes Admin contrib redirects compatibility problems introduced in Django 1. 4 by url handling changes. | 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().
... |
Generic redirect for item editor. | def _redirect(self, request, response):
"""Generic redirect for item editor."""
if '_addanother' in request.POST:
return HttpResponseRedirect('../item_add/')
elif '_save' in request.POST:
return HttpResponseRedirect('../')
elif '_continue' in request.POST:
... |
Redirects to the appropriate items continue page on item add. | 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 post_url_continue is None:
... |
Redirects to the appropriate items add page on item change. | 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 to redirection process.
"""
return self._redirect(request, super(TreeItemAdmin, self)... |
Returns modified form for TreeItem model. Parent field choices are built by sitetree itself. | 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.previ... |
Fetches Tree for current or given TreeItem. | 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)
self.tree.verbose_name_plural = self.tre... |
Moves item up or down by swapping sort_order field values of neighboring items. | 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:
... |
Saves TreeItem model under certain Tree. Handles item s parent assignment exception. | 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:
... |
Manages not only TreeAdmin URLs but also TreeItemAdmin URLs. | 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... |
Dumps sitetrees with items using django - smuggler. | def dump_view(cls, request):
"""Dumps sitetrees with items using django-smuggler.
:param request:
:return:
"""
from smuggler.views import dump_to_response
return dump_to_response(request, [MODEL_TREE, MODEL_TREE_ITEM], filename_prefix='sitetrees') |
Dynamically creates and returns a sitetree. | 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.... |
Dynamically creates and returns a sitetree item object. | 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... |
Imports sitetree module from a given app. | 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
module = import_module(app)
try:
sub_module = import_module('%s.%s' % (app, module_name))
... |
Imports sitetrees modules from packages ( apps ). Returns a list of submodules. | def import_project_sitetree_modules():
"""Imports sitetrees modules from packages (apps).
Returns a list of submodules.
:rtype: list
"""
from django.conf import settings as django_settings
submodules = []
for app in django_settings.INSTALLED_APPS:
module = import_app_sitetree_module... |
Returns tuple with application and tree [ item ] model class names. | def get_app_n_model(settings_entry_name):
"""Returns tuple with application and tree[item] model class names.
:param str|unicode settings_entry_name:
:rtype: tuple
"""
try:
app_name, model_name = getattr(settings, settings_entry_name).split('.')
except ValueError:
raise Improper... |
Returns a certain sitetree model as defined in the project settings. | 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, ... |
Called by the ASGI instance to send a message. | async def asgi_send(self, message: dict) -> None:
"""Called by the ASGI instance to send a message."""
if message["type"] == "http.response.start" and self.state == ASGIHTTPState.REQUEST:
self.response = message
elif message["type"] == "http.response.body" and self.state in {
... |
Called by the ASGI instance to send a message. | async def asgi_send(self, message: dict) -> None:
"""Called by the ASGI instance to send a message."""
if message["type"] == "websocket.accept" and self.state == ASGIWebsocketState.HANDSHAKE:
headers = build_and_validate_headers(message.get("headers", []))
raise_if_subprotocol_pr... |
Serve an ASGI framework app given the config. | async def serve(app: ASGIFramework, config: Config) -> None:
"""Serve an ASGI framework app given the config.
This allows for a programmatic way to serve an ASGI framework, it
can be used via,
.. code-block:: python
asyncio.run(serve(app, config))
It is assumed that the event-loop is con... |
Serve an ASGI framework app given the config. | async def serve(
app: ASGIFramework,
config: Config,
*,
task_status: trio._core._run._TaskStatus = trio.TASK_STATUS_IGNORED,
) -> None:
"""Serve an ASGI framework app given the config.
This allows for a programmatic way to serve an ASGI framework, it
can be used via,
.. code-block:: py... |
Create a configuration from a mapping. | 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
... |
Create a configuration from a Python file. | 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.
"""
... |
Load the configuration values from a TOML formatted file. | 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:
filename: The filena... |
Create a configuration from a Python object. | 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')
Conf... |
Main function to log all the annotations stored during the entire request. This is done if the request is sampled and the response was a success. It also logs the service ( ss and sr ) or the client ( cs and cr ) annotations. | def emit_spans(self):
"""Main function to log all the annotations stored during the entire
request. This is done if the request is sampled and the response was
a success. It also logs the service (`ss` and `sr`) or the client
('cs' and 'cr') annotations.
"""
# FIXME: Sho... |
Creates a set of zipkin attributes for a span. | 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-cha... |
Generate the headers for a new zipkin span. | 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... |
Returns the current ZipkinAttrs and generates new ones if needed. | 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, z... |
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. | 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
pushe... |
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. | 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 correc... |
Updates the binary annotations for the current span. | 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.bin... |
Adds a sa binary annotation to the current span. | 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... |
Overrides the current span name. | 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
c... |
Creates a new Endpoint object. | 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 addre... |
Creates a copy of a given endpoint with a new service name. | 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
:param new_service_name: new service name
:type new_service_name: str
:returns: zipkin new Endpo... |
Builds and returns a V1 Span. | 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',... |
Encode list of protobuf Spans to binary. | 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
"""
pb_list = zipkin_pb2.ListOfSpans()
pb_list.spans.extend(pb_spans)
return pb_list.Serial... |
Converts a py_zipkin Span in a protobuf Span. | 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.
# S... |
Encodes to hexadecimal ids to big - endian binary. | 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... |
Converts py_zipkin s Kind to Protobuf s Kind. | 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... |
Converts py_zipkin s Endpoint to Protobuf s Endpoint. | 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.Endpoi... |
Converts py_zipkin s annotations dict to protobuf. | 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():
... |
Create a zipkin annotation object | 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'
:param host: zipkin endpoint object
:returns: zipkin annotation object
"""
... |
Create a zipkin binary annotation object | 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 a URI
:param annotation_type: type of annotation, such as AnnotationType.I32
:param... |
Create a zipkin Endpoint object. | 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'
... |
Copies a copy of a given endpoint with a new service name. This should be very fast on the order of several microseconds. | 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 new service name
:returns:... |
Reformat annotations dict to return list of corresponding zipkin_core objects. | 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`
:... |
Reformat binary annotations dict to return list of zipkin_core objects. The value of the binary annotations MUST be in string format. | 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
... |
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. | 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
micros... |
Returns a TBinaryProtocol encoded Thrift span. | 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.
"""
transport = TMemoryBuffer()
protocol = TBinaryProtocol(transport)
thrift_span.write(protocol)
... |
Returns a TBinaryProtocol encoded list of Thrift objects. | 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.
"""
transport = TMemoryBuffer()
w... |
Returns the span type and encoding for the message provided. | 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 ... |
Converts encoded spans to a different encoding. | 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 encodin... |
Stores the zipkin attributes to thread local. | 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 zip... |
Returns a 128 bit UTF - 8 encoded string. Follows the same conventions as generate_random_64bit_string (). | def generate_random_128bit_string():
"""Returns a 128 bit UTF-8 encoded string. Follows the same conventions
as generate_random_64bit_string().
The upper 32 bits are the current time in epoch seconds, and the
lower 96 bits are random. This allows for AWS X-Ray `interop
<https://github.com/openzipki... |
Creates encoder object for the given encoding. | def get_encoder(encoding):
"""Creates encoder object for the given encoding.
:param encoding: desired output encoding protocol.
:type encoding: Encoding
:return: corresponding IEncoder object
:rtype: IEncoder
"""
if encoding == Encoding.V1_THRIFT:
return _V1ThriftEncoder()
if en... |
Checks if the new span fits in the max payload size. | def fits(self, current_count, current_size, max_size, new_span):
"""Checks if the new span fits in the max payload size.
Thrift lists have a fixed-size header and no delimiters between elements
so it's easy to compute the list size.
"""
return thrift.LIST_HEADER_SIZE + current_s... |
Encodes the current span to thrift. | 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,
)
... |
Converts an Endpoint to a JSON endpoint dict. | 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 em... |
Encodes a single span to JSON. | def encode_span(self, v2_span):
"""Encodes a single span to JSON."""
span = v2_span.build_v1_span()
json_span = {
'traceId': span.trace_id,
'name': span.name,
'id': span.id,
'annotations': [],
'binaryAnnotations': [],
}
... |
Encodes a single span to JSON. | def encode_span(self, span):
"""Encodes a single span to JSON."""
json_span = {
'traceId': span.trace_id,
'id': span.span_id,
}
if span.name:
json_span['name'] = span.name
if span.parent_id:
json_span['parentId'] = span.parent_id
... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.