INSTRUCTION stringlengths 1 8.43k | RESPONSE stringlengths 75 104k |
|---|---|
Returns the given URL with all query keys properly escaped. | def normalize_url(url):
"""
Returns the given URL with all query keys properly escaped.
Args:
url (str): The URL to normalize.
Returns:
str: The normalized URL.
"""
uri = urlparse(url)
query = uri.query or ""
pairs = parse_qsl(query)
decoded_pairs = [(unquote(key)... |
Define a write - only property that in addition to the given setter function also provides a setter decorator defined as the property s getter function. | def setter_decorator(fset):
"""
Define a write-only property that, in addition to the given setter function, also
provides a setter decorator defined as the property's getter function.
This allows one to set the property either through traditional assignment, as a
method argument, or through decora... |
bool: Whether the given value is valid. | def _valid_value(self, value):
""" bool: Whether the given value is valid. """
if not self.valid_values:
return True
valid_values = (self.valid_values if isinstance(self.valid_values, list)
else list(self.valid_values))
return value in valid_values |
Find a file field on the page and attach a file given its path. The file field can be found via its name id or label text.:: | def attach_file(self, locator_or_path, path=None, **kwargs):
"""
Find a file field on the page and attach a file given its path. The file field can be found
via its name, id, or label text. ::
page.attach_file(locator, "/path/to/file.png")
Args:
locator_or_path ... |
Find a check box and mark it as checked. The check box can be found via name id or label text.:: | def check(self, locator=None, allow_label_click=None, **kwargs):
"""
Find a check box and mark it as checked. The check box can be found via name, id, or label
text. ::
page.check("German")
Args:
locator (str, optional): Which check box to check.
all... |
Find a radio button and mark it as checked. The radio button can be found via name id or label text.:: | def choose(self, locator=None, allow_label_click=None, **kwargs):
"""
Find a radio button and mark it as checked. The radio button can be found via name, id, or
label text. ::
page.choose("Male")
Args:
locator (str, optional): Which radio button to choose.
... |
Locate a text field or text area and fill it in with the given text. The field can be found via its name id or label text.:: | def fill_in(self, locator=None, current_value=None, value=None, fill_options=None, **kwargs):
"""
Locate a text field or text area and fill it in with the given text. The field can be found
via its name, id, or label text. ::
page.fill_in("Name", value="Bob")
Args:
... |
If the field argument is present select finds a select box on the page and selects a particular option from it. Otherwise it finds an option inside the current scope and selects it. If the select box is a multiple select select can be called multiple times to select more than one option. The select box can be found via... | def select(self, value=None, field=None, **kwargs):
"""
If the ``field`` argument is present, ``select`` finds a select box on the page and selects
a particular option from it. Otherwise it finds an option inside the current scope and
selects it. If the select box is a multiple select, `... |
Find a check box and uncheck it. The check box can be found via name id or label text.:: | def uncheck(self, locator=None, allow_label_click=None, **kwargs):
"""
Find a check box and uncheck it. The check box can be found via name, id, or label text. ::
page.uncheck("German")
Args:
locator (str, optional): Which check box to uncheck.
allow_label_c... |
Find a select box on the page and unselect a particular option from it. If the select box is a multiple select unselect can be called multiple times to unselect more than one option. The select box can be found via its name id or label text.:: | def unselect(self, value=None, field=None, **kwargs):
"""
Find a select box on the page and unselect a particular option from it. If the select box is
a multiple select, ``unselect`` can be called multiple times to unselect more than one
option. The select box can be found via its name, ... |
Args: selector ( str ): The selector for the type of element that should be checked/ unchecked. checked ( bool ): Whether the element should be checked. locator ( str optional ): Which element to check. allow_label_click ( bool optional ): Attempt to click the label to toggle state if element is non - visible. Defaults... | def _check_with_label(self, selector, checked, locator=None, allow_label_click=None, visible=None, wait=None,
**kwargs):
"""
Args:
selector (str): The selector for the type of element that should be checked/unchecked.
checked (bool): Whether the element ... |
Decorator for: meth: synchronize. | def synchronize(func):
""" Decorator for :meth:`synchronize`. """
@wraps(func)
def outer(self, *args, **kwargs):
@self.synchronize
def inner(self, *args, **kwargs):
return func(self, *args, **kwargs)
return inner(self, *args, **kwargs)
return outer |
This method is Capybara s primary defense against asynchronicity problems. It works by attempting to run a given decorated function until it succeeds. The exact behavior of this method depends on a number of factors. Basically there are certain exceptions which when raised from the decorated function instead of bubblin... | def synchronize(self, func=None, wait=None, errors=()):
"""
This method is Capybara's primary defense against asynchronicity problems. It works by
attempting to run a given decorated function until it succeeds. The exact behavior of this
method depends on a number of factors. Basically t... |
Returns whether to catch the given error. | def _should_catch_error(self, error, errors=()):
"""
Returns whether to catch the given error.
Args:
error (Exception): The error to consider.
errors (Tuple[Type[Exception], ...], optional): The exception types that should be
caught. Defaults to :class:`E... |
Returns how the result count compares to the query options. | def compare_count(self):
"""
Returns how the result count compares to the query options.
The return value is negative if too few results were found, zero if enough were found, and
positive if too many were found.
Returns:
int: -1, 0, or 1.
"""
if se... |
str: A message describing the query failure. | def failure_message(self):
""" str: A message describing the query failure. """
message = failure_message(self.query.description, self.query.options)
if len(self) > 0:
message += ", found {count} {matches}: {results}".format(
count=len(self),
matches... |
Attempts to fill the result cache with at least the given number of results. | def _cache_at_least(self, size):
"""
Attempts to fill the result cache with at least the given number of results.
Returns:
bool: Whether the cache contains at least the given size.
"""
try:
while len(self._result_cache) < size:
self._resu... |
str: A normalized representation for a user - provided value. | def desc(value):
""" str: A normalized representation for a user-provided value. """
def normalize_strings(value):
if isinstance(value, list):
value = [normalize_strings(e) for e in value]
if isinstance(value, dict):
value = {normalize_strings(k): normalize_strings(v) f... |
Returns whether the given query options expect a possible count of zero. | def expects_none(options):
"""
Returns whether the given query options expect a possible count of zero.
Args:
options (Dict[str, int | Iterable[int]]): A dictionary of query options.
Returns:
bool: Whether a possible count of zero is expected.
"""
if any(options.get(key) is no... |
Returns a expectation failure message for the given query description. | def failure_message(description, options):
"""
Returns a expectation failure message for the given query description.
Args:
description (str): A description of the failed query.
options (Dict[str, Any]): The query options.
Returns:
str: A message describing the failure.
"""... |
Returns whether the given count matches the given query options. | def matches_count(count, options):
"""
Returns whether the given count matches the given query options.
If no quantity options are specified, any count is considered acceptable.
Args:
count (int): The count to be validated.
options (Dict[str, int | Iterable[int]]): A dictionary of quer... |
Normalizes the given value to a string of text with extra whitespace removed. | def normalize_text(value):
"""
Normalizes the given value to a string of text with extra whitespace removed.
Byte sequences are decoded. ``None`` is converted to an empty string. Everything else
is simply cast to a string.
Args:
value (Any): The data to normalize.
Returns:
str... |
Returns the given text with outer whitespace removed and inner whitespace collapsed. | def normalize_whitespace(text):
"""
Returns the given text with outer whitespace removed and inner whitespace collapsed.
Args:
text (str): The text to normalize.
Returns:
str: The normalized text.
"""
return re.sub(r"\s+", " ", text, flags=re.UNICODE).strip() |
Returns a compiled regular expression for the given text. | def toregex(text, exact=False):
"""
Returns a compiled regular expression for the given text.
Args:
text (str | RegexObject): The text to match.
exact (bool, optional): Whether the generated regular expression should match exact
strings. Defaults to False.
Returns:
... |
Returns whether this query resolves for the given session. | def resolves_for(self, session):
"""
Returns whether this query resolves for the given session.
Args:
session (Session): The session for which this query should be executed.
Returns:
bool: Whether this query resolves.
"""
if self.url:
... |
bool: Whether this window is the window in which commands are being executed. | def current(self):
""" bool: Whether this window is the window in which commands are being executed. """
try:
return self.driver.current_window_handle == self.handle
except self.driver.no_such_window_error:
return False |
Resizes the window to the given dimensions. | def resize_to(self, width, height):
"""
Resizes the window to the given dimensions.
If this method was called for a window that is not current, then after calling this method
the current window should remain the same as it was before calling this method.
Args:
width... |
Boots a server for the app if it isn t already booted. | def boot(self):
"""
Boots a server for the app, if it isn't already booted.
Returns:
Server: This server.
"""
if not self.responsive:
# Remember the port so we can reuse it if we try to serve this same app again.
type(self)._ports[self.port_k... |
bool: Whether the server for this app is up and responsive. | def responsive(self):
""" bool: Whether the server for this app is up and responsive. """
if self.server_thread and self.server_thread.join(0):
return False
try:
# Try to fetch the endpoint added by the middleware.
identify_url = "http://{0}:{1}/__identify__... |
Descriptor to change the class wide getter on a property. | def cgetter(self, fcget: typing.Optional[typing.Callable[[typing.Any], typing.Any]]) -> "AdvancedProperty":
"""Descriptor to change the class wide getter on a property.
:param fcget: new class-wide getter.
:type fcget: typing.Optional[typing.Callable[[typing.Any, ], typing.Any]]
:return... |
Descriptor to change instance method. | def instance_method(self, imeth: typing.Optional[typing.Callable[..., typing.Any]]) -> "SeparateClassMethod":
"""Descriptor to change instance method.
:param imeth: New instance method.
:type imeth: typing.Optional[typing.Callable]
:return: SeparateClassMethod
:rtype: SeparateCl... |
Descriptor to change class method. | def class_method(self, cmeth: typing.Optional[typing.Callable[..., typing.Any]]) -> "SeparateClassMethod":
"""Descriptor to change class method.
:param cmeth: New class method.
:type cmeth: typing.Optional[typing.Callable]
:return: SeparateClassMethod
:rtype: SeparateClassMethod... |
Get outer traceback text for logging. | def __traceback(self) -> str:
"""Get outer traceback text for logging."""
if not self.log_traceback:
return ""
exc_info = sys.exc_info()
stack = traceback.extract_stack()
exc_tb = traceback.extract_tb(exc_info[2])
full_tb = stack[:1] + exc_tb # cut decorator ... |
Get object repr block. | def __get_obj_source(self, instance: typing.Any, owner: typing.Optional[type] = None) -> str:
"""Get object repr block."""
if self.log_object_repr:
return f"{instance!r}"
return f"<{owner.__name__ if owner is not None else instance.__class__.__name__}() at 0x{id(instance):X}>" |
Get logger for log calls. | def _get_logger_for_instance(self, instance: typing.Any) -> logging.Logger:
"""Get logger for log calls.
:param instance: Owner class instance. Filled only if instance created, else None.
:type instance: typing.Optional[owner]
:return: logger instance
:rtype: logging.Logger
... |
Logger instance to use as override. | def logger(self, logger: typing.Union[logging.Logger, str, None]) -> None:
"""Logger instance to use as override."""
if logger is None or isinstance(logger, logging.Logger):
self.__logger = logger
else:
self.__logger = logging.getLogger(logger) |
Get simple ( string/ number/ boolean and None ) assigned values from source. | def get_simple_vars_from_src(src):
"""Get simple (string/number/boolean and None) assigned values from source.
:param src: Source code
:type src: str
:returns: OrderedDict with keys, values = variable names, values
:rtype: typing.Dict[
str,
typing.Union[
... |
Run. | def run(self):
"""Run.
:raises BuildFailed: extension build failed and need to skip cython part.
"""
try:
build_ext.build_ext.run(self)
# Copy __init__.py back to repair package.
build_dir = os.path.abspath(self.build_lib)
root_dir = os.p... |
Low - level method to call the Slack API. | def _call_api(self, method, params=None):
"""
Low-level method to call the Slack API.
Args:
method: {str} method name to call
params: {dict} GET parameters
The token will always be added
"""
url = self.url.format(method=method)
if ... |
List of channels of this slack team | def channels(self):
"""
List of channels of this slack team
"""
if not self._channels:
self._channels = self._call_api('channels.list')['channels']
return self._channels |
List of users of this slack team | def users(self):
"""
List of users of this slack team
"""
if not self._users:
self._users = self._call_api('users.list')['members']
return self._users |
Return the channel dict given by human - readable { name } | def channel_from_name(self, name):
"""
Return the channel dict given by human-readable {name}
"""
try:
channel = [channel for channel in self.channels
if channel['name'] == name][0]
except IndexError:
raise ValueError('Unknown channe... |
High - level function for creating messages. Return packed bytes. | def make_message(self, text, channel):
"""
High-level function for creating messages. Return packed bytes.
Args:
text: {str}
channel: {str} Either name or ID
"""
try:
channel_id = self.slack.channel_from_name(channel)['id']
except Valu... |
Translate machine identifiers into human - readable | def translate(self, message):
"""
Translate machine identifiers into human-readable
"""
# translate user
try:
user_id = message.pop('user')
user = self.slack.user_from_id(user_id)
message[u'user'] = user['name']
except (KeyError, IndexE... |
Send the payload onto the { slack. [ payload [ type ] } channel. The message is transalated from IDs to human - readable identifiers. | def onMessage(self, payload, isBinary):
"""
Send the payload onto the {slack.[payload['type]'} channel.
The message is transalated from IDs to human-readable identifiers.
Note: The slack API only sends JSON, isBinary will always be false.
"""
msg = self.translate(unpack(... |
Send message to Slack | def sendSlack(self, message):
"""
Send message to Slack
"""
channel = message.get('channel', 'general')
self.sendMessage(self.make_message(message['text'], channel)) |
Get available messages and send through to the protocol | def read_channel(self):
"""
Get available messages and send through to the protocol
"""
channel, message = self.protocol.channel_layer.receive_many([u'slack.send'], block=False)
delay = 0.1
if channel:
self.protocols[0].sendSlack(message)
reactor.callL... |
Main interface. Instantiate the SlackAPI connect to RTM and start the client. | def run(self):
"""
Main interface. Instantiate the SlackAPI, connect to RTM
and start the client.
"""
slack = SlackAPI(token=self.token)
rtm = slack.rtm_start()
factory = SlackClientFactory(rtm['url'])
# Attach attributes
factory.protocol = SlackC... |
Pass in raw arguments instantiate Slack API and begin client. | def run(self, args):
"""
Pass in raw arguments, instantiate Slack API and begin client.
"""
args = self.parser.parse_args(args)
if not args.token:
raise ValueError('Supply the slack token through --token or setting DJANGOBOT_TOKEN')
# Import the channel layer... |
Setter method for affiliation mapped from YANG variable/ universe/ individual/ affiliation ( identityref ) If this variable is read - only ( config: false ) in the source YANG file then _set_affiliation is considered as a private method. Backends looking to populate this variable should do so via calling thisObj. _set_... | def _set_affiliation(self, v, load=False):
"""
Setter method for affiliation, mapped from YANG variable /universe/individual/affiliation (identityref)
If this variable is read-only (config: false) in the
source YANG file, then _set_affiliation is considered as a private
method. Backends looking ... |
Return a dict of keys that differ with another config object. | def dict_diff(prv, nxt):
"""Return a dict of keys that differ with another config object."""
keys = set(prv.keys() + nxt.keys())
result = {}
for k in keys:
if prv.get(k) != nxt.get(k):
result[k] = (prv.get(k), nxt.get(k))
return result |
Given a string add necessary codes to format the string. | def colorize(msg, color):
"""Given a string add necessary codes to format the string."""
if DONT_COLORIZE:
return msg
else:
return "{}{}{}".format(COLORS[color], msg, COLORS["endc"]) |
Run when a task starts. | def v2_playbook_on_task_start(self, task, **kwargs):
"""Run when a task starts."""
self.last_task_name = task.get_name()
self.printed_last_task = False |
Run when a task finishes correctly. | def v2_runner_on_ok(self, result, **kwargs):
"""Run when a task finishes correctly."""
failed = "failed" in result._result
unreachable = "unreachable" in result._result
if (
"print_action" in result._task.tags
or failed
or unreachable
or s... |
Display info about playbook statistics. | def v2_playbook_on_stats(self, stats):
"""Display info about playbook statistics."""
print()
self.printed_last_task = False
self._print_task("STATS")
hosts = sorted(stats.processed.keys())
for host in hosts:
s = stats.summarize(host)
if s["failur... |
Run when a task is skipped. | def v2_runner_on_skipped(self, result, **kwargs):
"""Run when a task is skipped."""
if self._display.verbosity > 1:
self._print_task()
self.last_skipped = False
line_length = 120
spaces = " " * (31 - len(result._host.name) - 4)
line = " * {}... |
This methid basically reads a configuration that conforms to a very poor industry standard and returns a nested structure that behaves like a dict. For example: { enable password whatever: {} interface GigabitEthernet1: { description bleh: {} fake nested: { nested nested configuration: {} } switchport mode trunk: {} } ... | def parse_indented_config(config, current_indent=0, previous_indent=0, nested=False):
"""
This methid basically reads a configuration that conforms to a very poor industry standard
and returns a nested structure that behaves like a dict. For example:
{'enable password whatever': {},
'interf... |
Converts a CIDR formatted prefix into an address netmask representation. Argument sep specifies the separator between the address and netmask parts. By default it s a single space. | def prefix_to_addrmask(value, sep=" "):
"""
Converts a CIDR formatted prefix into an address netmask representation.
Argument sep specifies the separator between the address and netmask parts.
By default it's a single space.
Examples:
>>> "{{ '192.168.0.1/24|prefix_to_addrmask }}" -> "192.1... |
Setter method for keepalive_interval mapped from YANG variable/ network_instances/ network_instance/ protocols/ protocol/ bgp/ peer_groups/ peer_group/ timers/ state/ keepalive_interval ( decimal64 ) If this variable is read - only ( config: false ) in the source YANG file then _set_keepalive_interval is considered as ... | def _set_keepalive_interval(self, v, load=False):
"""
Setter method for keepalive_interval, mapped from YANG variable /network_instances/network_instance/protocols/protocol/bgp/peer_groups/peer_group/timers/state/keepalive_interval (decimal64)
If this variable is read-only (config: false) in the
sou... |
Decorator that checks if a value passed to a Jinja filter evaluates to false and returns an empty string. Otherwise calls the original Jinja filter. | def check_empty(default=""):
"""
Decorator that checks if a value passed to a Jinja filter evaluates to false
and returns an empty string. Otherwise calls the original Jinja filter.
Example usage:
@check_empty
def my_jinja_filter(value, arg1):
"""
def real_decorator(func):
@wr... |
Add a model. | def add_model(self, model, force=False):
"""
Add a model.
The model will be asssigned to a class attribute with the YANG name of the model.
Args:
model (PybindBase): Model to add.
force (bool): If not set, verify the model is in SUPPORTED_MODELS
Example... |
Returns a dictionary with the values of the model. Note that the values of the leafs are YANG classes. | def get(self, filter=False):
"""
Returns a dictionary with the values of the model. Note that the values
of the leafs are YANG classes.
Args:
filter (bool): If set to ``True``, show only values that have been set.
Returns:
dict: A dictionary with the val... |
Load a dictionary into the model. | def load_dict(self, data, overwrite=False, auto_load_model=True):
"""
Load a dictionary into the model.
Args:
data(dict): Dictionary to load
overwrite(bool): Whether the data present in the model should be overwritten by the
data in the dict or not.
... |
Returns a dictionary with the values of the model. Note that the values of the leafs are evaluated to python types. | def to_dict(self, filter=True):
"""
Returns a dictionary with the values of the model. Note that the values
of the leafs are evaluated to python types.
Args:
filter (bool): If set to ``True``, show only values that have been set.
Returns:
dict: A diction... |
Parse native configuration and load it into the corresponding models. Only models that have been added to the root object will be parsed. | def parse_config(self, device=None, profile=None, native=None, attrs=None):
"""
Parse native configuration and load it into the corresponding models. Only models
that have been added to the root object will be parsed.
If ``native`` is passed to the method that's what we will parse, othe... |
Parse native state and load it into the corresponding models. Only models that have been added to the root object will be parsed. | def parse_state(self, device=None, profile=None, native=None, attrs=None):
"""
Parse native state and load it into the corresponding models. Only models
that have been added to the root object will be parsed.
If ``native`` is passed to the method that's what we will parse, otherwise, we... |
Translate the object to native configuration. | def translate_config(self, profile, merge=None, replace=None):
"""
Translate the object to native configuration.
In this context, merge and replace means the following:
* **Merge** - Elements that exist in both ``self`` and ``merge`` will use by default the
values in ``merge`... |
Loads and returns all filters. | def load_filters():
"""
Loads and returns all filters.
"""
all_filters = {}
for m in JINJA_FILTERS:
if hasattr(m, "filters"):
all_filters.update(m.filters())
return all_filters |
This helps parsing shit like: | def _parse_list_nested_recursive(
cls, data, path, iterators, list_vars, cur_vars=None
):
"""
This helps parsing shit like:
<protocols>
<bgp>
<group>
<name>my_peers</name>
<neighbor>
... |
This method tries to use the path ?my_field to convert: | def _flatten_dictionary(obj, path, key_name):
"""
This method tries to use the path `?my_field` to convert:
a:
aa: 1
ab: 2
b:
ba: 3
ba: 4
into:
- my_field: a
aa: 1
ab: 2
- my_field: b
ba: 3
ba: 4
"""
result = []
if ">" in... |
Setter method for trunk_vlans mapped from YANG variable/ interfaces/ interface/ aggregation/ switched_vlan/ state/ trunk_vlans ( union ) If this variable is read - only ( config: false ) in the source YANG file then _set_trunk_vlans is considered as a private method. Backends looking to populate this variable should do... | def _set_trunk_vlans(self, v, load=False):
"""
Setter method for trunk_vlans, mapped from YANG variable /interfaces/interface/aggregation/switched_vlan/state/trunk_vlans (union)
If this variable is read-only (config: false) in the
source YANG file, then _set_trunk_vlans is considered as a private
... |
Find the necessary file for the given test case. | def find_yang_file(profile, filename, path):
"""
Find the necessary file for the given test case.
Args:
device(napalm device connection): for which device
filename(str): file to find
path(str): where to find it relative to where the module is installed
"""
# Find base_dir of... |
Given a model return a representation of the model in a dict. | def model_to_dict(model, mode="", show_defaults=False):
"""
Given a model, return a representation of the model in a dict.
This is mostly useful to have a quick visual represenation of the model.
Args:
model (PybindBase): Model to transform.
mode (string): Whether to print config, sta... |
Given two models return the difference between them. | def diff(f, s):
"""
Given two models, return the difference between them.
Args:
f (Pybindbase): First element.
s (Pybindbase): Second element.
Returns:
dict: A dictionary highlighting the differences.
Examples:
>>> diff = napalm_yang.utils.diff(candidate, runnin... |
POST to URL and get result as a response object. | def http_post(self, url, data=None):
"""POST to URL and get result as a response object.
:param url: URL to POST.
:type url: str
:param data: Data to send in the form body.
:type data: str
:rtype: requests.Response
"""
if not url.startswith('https://'):
... |
Construct a full URL that can be used to obtain an authorization code from the provider authorization_uri. Use this URI in a client frame to cause the provider to generate an authorization code. | def get_authorization_code_uri(self, **params):
"""Construct a full URL that can be used to obtain an authorization
code from the provider authorization_uri. Use this URI in a client
frame to cause the provider to generate an authorization code.
:rtype: str
"""
if 'respo... |
Get an access token from the provider token URI. | def get_token(self, code, **params):
"""Get an access token from the provider token URI.
:param code: Authorization code.
:type code: str
:return: Dict containing access token, refresh token, etc.
:rtype: dict
"""
params['code'] = code
if 'grant_type' not... |
Return query parameters as a dict from the specified URL. | def url_query_params(url):
"""Return query parameters as a dict from the specified URL.
:param url: URL.
:type url: str
:rtype: dict
"""
return dict(urlparse.parse_qsl(urlparse.urlparse(url).query, True)) |
Return a URL with the query component removed. | def url_dequery(url):
"""Return a URL with the query component removed.
:param url: URL to dequery.
:type url: str
:rtype: str
"""
url = urlparse.urlparse(url)
return urlparse.urlunparse((url.scheme,
url.netloc,
url.path,
... |
Construct a URL based off of base containing all parameters in the query portion of base plus any additional parameters. | def build_url(base, additional_params=None):
"""Construct a URL based off of base containing all parameters in
the query portion of base plus any additional parameters.
:param base: Base URL
:type base: str
::param additional_params: Additional query parameters to include.
:type additional_para... |
Handle an internal exception that was caught and suppressed. | def _handle_exception(self, exc):
"""Handle an internal exception that was caught and suppressed.
:param exc: Exception to process.
:type exc: Exception
"""
logger = logging.getLogger(__name__)
logger.exception(exc) |
Return a response object from the given parameters. | def _make_response(self, body='', headers=None, status_code=200):
"""Return a response object from the given parameters.
:param body: Buffer/string containing the response body.
:type body: str
:param headers: Dict of headers to include in the requests.
:type headers: dict
... |
Return a HTTP 302 redirect response object containing the error. | def _make_redirect_error_response(self, redirect_uri, err):
"""Return a HTTP 302 redirect response object containing the error.
:param redirect_uri: Client redirect URI.
:type redirect_uri: str
:param err: OAuth error message.
:type err: str
:rtype: requests.Response
... |
Return a response object from the given JSON data. | def _make_json_response(self, data, headers=None, status_code=200):
"""Return a response object from the given JSON data.
:param data: Data to JSON-encode.
:type data: mixed
:param headers: Dict of headers to include in the requests.
:type headers: dict
:param status_cod... |
Generate authorization code HTTP response. | def get_authorization_code(self,
response_type,
client_id,
redirect_uri,
**params):
"""Generate authorization code HTTP response.
:param response_type: Desired response type. Must... |
Generate access token HTTP response from a refresh token. | def refresh_token(self,
grant_type,
client_id,
client_secret,
refresh_token,
**params):
"""Generate access token HTTP response from a refresh token.
:param grant_type: Desired grant type. Must ... |
Generate access token HTTP response. | def get_token(self,
grant_type,
client_id,
client_secret,
redirect_uri,
code,
**params):
"""Generate access token HTTP response.
:param grant_type: Desired grant type. Must be "authorization_code... |
Get authorization code response from a URI. This method will ignore the domain and path of the request instead automatically parsing the query string parameters. | def get_authorization_code_from_uri(self, uri):
"""Get authorization code response from a URI. This method will
ignore the domain and path of the request, instead
automatically parsing the query string parameters.
:param uri: URI to parse for authorization information.
:type uri... |
Get a token response from POST data. | def get_token_from_post_data(self, data):
"""Get a token response from POST data.
:param data: POST data containing authorization information.
:type data: dict
:rtype: requests.Response
"""
try:
# Verify OAuth 2.0 Parameters
for x in ['grant_type'... |
Get authorization object representing status of authentication. | def get_authorization(self):
"""Get authorization object representing status of authentication."""
auth = self.authorization_class()
header = self.get_authorization_header()
if not header or not header.split:
return auth
header = header.split()
if len(header) ... |
Utility function to create and return an i2c_rdwr_ioctl_data structure populated with a list of specified I2C messages. The messages parameter should be a list of tuples which represent the individual I2C messages to send in this transaction. Tuples should contain 4 elements: address value flags value buffer length cty... | def make_i2c_rdwr_data(messages):
"""Utility function to create and return an i2c_rdwr_ioctl_data structure
populated with a list of specified I2C messages. The messages parameter
should be a list of tuples which represent the individual I2C messages to
send in this transaction. Tuples should contain ... |
Open the smbus interface on the specified bus. | def open(self, bus):
"""Open the smbus interface on the specified bus."""
# Close the device if it's already open.
if self._device is not None:
self.close()
# Try to open the file for the specified bus. Must turn off buffering
# or else Python 3 fails (see: https://b... |
Read a single byte from the specified device. | def read_byte(self, addr):
"""Read a single byte from the specified device."""
assert self._device is not None, 'Bus must be opened before operations are made against it!'
self._select_device(addr)
return ord(self._device.read(1)) |
Read many bytes from the specified device. | def read_bytes(self, addr, number):
"""Read many bytes from the specified device."""
assert self._device is not None, 'Bus must be opened before operations are made against it!'
self._select_device(addr)
return self._device.read(number) |
Read a single byte from the specified cmd register of the device. | def read_byte_data(self, addr, cmd):
"""Read a single byte from the specified cmd register of the device."""
assert self._device is not None, 'Bus must be opened before operations are made against it!'
# Build ctypes values to marshall between ioctl and Python.
reg = c_uint8(cmd)
... |
Read a word ( 2 bytes ) from the specified cmd register of the device. Note that this will interpret data using the endianness of the processor running Python ( typically little endian ) ! | def read_word_data(self, addr, cmd):
"""Read a word (2 bytes) from the specified cmd register of the device.
Note that this will interpret data using the endianness of the processor
running Python (typically little endian)!
"""
assert self._device is not None, 'Bus must be opened... |
Perform a read from the specified cmd register of device. Length number of bytes ( default of 32 ) will be read and returned as a bytearray. | def read_i2c_block_data(self, addr, cmd, length=32):
"""Perform a read from the specified cmd register of device. Length number
of bytes (default of 32) will be read and returned as a bytearray.
"""
assert self._device is not None, 'Bus must be opened before operations are made against ... |
Write a single byte to the specified device. | def write_quick(self, addr):
"""Write a single byte to the specified device."""
# What a strange function, from the python-smbus source this appears to
# just write a single byte that initiates a write to the specified device
# address (but writes no data!). The functionality is duplica... |
Write a single byte to the specified device. | def write_byte(self, addr, val):
"""Write a single byte to the specified device."""
assert self._device is not None, 'Bus must be opened before operations are made against it!'
self._select_device(addr)
data = bytearray(1)
data[0] = val & 0xFF
self._device.write(data) |
Write many bytes to the specified device. buf is a bytearray | def write_bytes(self, addr, buf):
"""Write many bytes to the specified device. buf is a bytearray"""
assert self._device is not None, 'Bus must be opened before operations are made against it!'
self._select_device(addr)
self._device.write(buf) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.