INSTRUCTION stringlengths 1 8.43k | RESPONSE stringlengths 75 104k |
|---|---|
Add Auth configuration to the Swagger file if necessary | def _add_auth(self):
"""
Add Auth configuration to the Swagger file, if necessary
"""
if not self.auth:
return
if self.auth and not self.definition_body:
raise InvalidResourceException(self.logical_id,
"Auth wor... |
Add Gateway Response configuration to the Swagger file if necessary | def _add_gateway_responses(self):
"""
Add Gateway Response configuration to the Swagger file, if necessary
"""
if not self.gateway_responses:
return
if self.gateway_responses and not self.definition_body:
raise InvalidResourceException(
s... |
Constructs and returns the Lambda Permission resource allowing the Authorizer to invoke the function. | def _get_permission(self, authorizer_name, authorizer_lambda_function_arn):
"""Constructs and returns the Lambda Permission resource allowing the Authorizer to invoke the function.
:returns: the permission resource
:rtype: model.lambda_.LambdaPermission
"""
rest_api = ApiGateway... |
Sets endpoint configuration property of AWS:: ApiGateway:: RestApi resource: param rest_api: RestApi resource: param string/ dict value: Value to be set | def _set_endpoint_configuration(self, rest_api, value):
"""
Sets endpoint configuration property of AWS::ApiGateway::RestApi resource
:param rest_api: RestApi resource
:param string/dict value: Value to be set
"""
rest_api.EndpointConfiguration = {"Types": [value]}
... |
The retry function will keep retrying task_to_try until either: ( 1 ) it returns None then retry () finishes ( 2 ) max_attempts is reached then retry () raises an exception. ( 3 ) if retrying one more time will cause total wait time to go above: expiration_duration then retry () raises an exception | def retry(time_unit, multiplier, backoff_coefficient, max_delay, max_attempts, expiration_duration, enable_jitter):
"""
The retry function will keep retrying `task_to_try` until either:
(1) it returns None, then retry() finishes
(2) `max_attempts` is reached, then retry() raises an exception.
(3) if... |
Returns the Lambda function role and event resources to which this SAM Function corresponds. | def to_cloudformation(self, **kwargs):
"""Returns the Lambda function, role, and event resources to which this SAM Function corresponds.
:param dict kwargs: already-converted resources that may need to be modified when converting this \
macro to pure CloudFormation
:returns: a list of v... |
Alias names can be supplied as an intrinsic function. This method tries to extract alias name from a reference to a parameter. If it cannot completely resolve ( ie. if a complex intrinsic function was used ) then this method raises an exception. If alias name is just a plain string it will return as is | def _get_resolved_alias_name(self, property_name, original_alias_value, intrinsics_resolver):
"""
Alias names can be supplied as an intrinsic function. This method tries to extract alias name from a reference
to a parameter. If it cannot completely resolve (ie. if a complex intrinsic function wa... |
Constructs and returns the Lambda function. | def _construct_lambda_function(self):
"""Constructs and returns the Lambda function.
:returns: a list containing the Lambda function and execution role resources
:rtype: list
"""
lambda_function = LambdaFunction(self.logical_id, depends_on=self.depends_on,
... |
Constructs a Lambda execution role based on this SAM function s Policies property. | def _construct_role(self, managed_policy_map):
"""Constructs a Lambda execution role based on this SAM function's Policies property.
:returns: the generated IAM Role
:rtype: model.iam.IAMRole
"""
execution_role = IAMRole(self.logical_id + 'Role', attributes=self.get_passthrough_... |
Validates whether the DeadLetterQueue LogicalId is validation: raise: InvalidResourceException | def _validate_dlq(self):
"""Validates whether the DeadLetterQueue LogicalId is validation
:raise: InvalidResourceException
"""
# Validate required logical ids
valid_dlq_types = str(list(self.dead_letter_queue_policy_actions.keys()))
if not self.DeadLetterQueue.get('Type')... |
Generates and returns the resources associated with this function s events. | def _generate_event_resources(self, lambda_function, execution_role, event_resources, lambda_alias=None):
"""Generates and returns the resources associated with this function's events.
:param model.lambda_.LambdaFunction lambda_function: generated Lambda function
:param iam.IAMRole execution_ro... |
Constructs a Lambda Version resource that will be auto - published when CodeUri of the function changes. Old versions will not be deleted without a direct reference from the CloudFormation template. | def _construct_version(self, function, intrinsics_resolver):
"""Constructs a Lambda Version resource that will be auto-published when CodeUri of the function changes.
Old versions will not be deleted without a direct reference from the CloudFormation template.
:param model.lambda_.LambdaFunctio... |
Constructs a Lambda Alias for the given function and pointing to the given version | def _construct_alias(self, name, function, version):
"""Constructs a Lambda Alias for the given function and pointing to the given version
:param string name: Name of the alias
:param model.lambda_.LambdaFunction function: Lambda function object to associate the alias with
:param model.... |
Returns the API Gateway RestApi Deployment and Stage to which this SAM Api corresponds. | def to_cloudformation(self, **kwargs):
"""Returns the API Gateway RestApi, Deployment, and Stage to which this SAM Api corresponds.
:param dict kwargs: already-converted resources that may need to be modified when converting this \
macro to pure CloudFormation
:returns: a list of vanill... |
Constructs a AWS:: CloudFormation:: Stack resource | def _construct_nested_stack(self):
"""Constructs a AWS::CloudFormation::Stack resource
"""
nested_stack = NestedStack(self.logical_id, depends_on=self.depends_on,
attributes=self.get_passthrough_resource_attributes())
nested_stack.Parameters = self.Para... |
Adds tags to the stack if this resource is using the serverless app repo | def _get_application_tags(self):
"""Adds tags to the stack if this resource is using the serverless app repo
"""
application_tags = {}
if isinstance(self.Location, dict):
if (self.APPLICATION_ID_KEY in self.Location.keys() and
self.Location[self.APPLICATIO... |
Returns the Lambda layer to which this SAM Layer corresponds. | def to_cloudformation(self, **kwargs):
"""Returns the Lambda layer to which this SAM Layer corresponds.
:param dict kwargs: already-converted resources that may need to be modified when converting this \
macro to pure CloudFormation
:returns: a list of vanilla CloudFormation Resources, ... |
Constructs and returns the Lambda function. | def _construct_lambda_layer(self, intrinsics_resolver):
"""Constructs and returns the Lambda function.
:returns: a list containing the Lambda function and execution role resources
:rtype: list
"""
# Resolve intrinsics if applicable:
self.LayerName = self._resolve_string_... |
Sets the deletion policy on this resource. The default is Retain. | def _get_retention_policy_value(self):
"""
Sets the deletion policy on this resource. The default is 'Retain'.
:return: value for the DeletionPolicy attribute.
"""
if self.RetentionPolicy is None or self.RetentionPolicy.lower() == self.RETAIN.lower():
return self.RE... |
Performs dialog management and fulfillment for ordering flowers. Beyond fulfillment the implementation of this intent demonstrates the use of the elicitSlot dialog action in slot validation and re - prompting. | def order_flowers(intent_request):
"""
Performs dialog management and fulfillment for ordering flowers.
Beyond fulfillment, the implementation of this intent demonstrates the use of the elicitSlot dialog action
in slot validation and re-prompting.
"""
flower_type = get_slots(intent_request)["Fl... |
Called when the user specifies an intent for this bot. | def dispatch(intent_request):
"""
Called when the user specifies an intent for this bot.
"""
logger.debug('dispatch userId={}, intentName={}'.format(intent_request['userId'], intent_request['currentIntent']['name']))
intent_name = intent_request['currentIntent']['name']
# Dispatch to your bot... |
Constructs the Lambda Permission resource allowing the source service to invoke the function this event source triggers. | def _construct_permission(self, function, source_arn=None, source_account=None, suffix="", event_source_token=None):
"""Constructs the Lambda Permission resource allowing the source service to invoke the function this event
source triggers.
:returns: the permission resource
:rtype: mode... |
Returns the CloudWatch Events Rule and Lambda Permission to which this Schedule event source corresponds. | def to_cloudformation(self, **kwargs):
"""Returns the CloudWatch Events Rule and Lambda Permission to which this Schedule event source corresponds.
:param dict kwargs: no existing resources need to be modified
:returns: a list of vanilla CloudFormation Resources, to which this pull event expand... |
Constructs the Target property for the CloudWatch Events Rule. | def _construct_target(self, function):
"""Constructs the Target property for the CloudWatch Events Rule.
:returns: the Target property
:rtype: dict
"""
target = {
'Arn': function.get_runtime_attr("arn"),
'Id': self.logical_id + 'LambdaTarget'
... |
Returns the Lambda Permission resource allowing S3 to invoke the function this event source triggers. | def to_cloudformation(self, **kwargs):
"""Returns the Lambda Permission resource allowing S3 to invoke the function this event source triggers.
:param dict kwargs: S3 bucket resource
:returns: a list of vanilla CloudFormation Resources, to which this S3 event expands
:rtype: list
... |
Make the S3 bucket depends on Lambda Permissions resource because when S3 adds a Notification Configuration it will check whether it has permissions to access Lambda. This will fail if the Lambda:: Permissions is not already applied for this bucket to invoke the Lambda. | def _depend_on_lambda_permissions(self, bucket, permission):
"""
Make the S3 bucket depends on Lambda Permissions resource because when S3 adds a Notification Configuration,
it will check whether it has permissions to access Lambda. This will fail if the Lambda::Permissions is not
alread... |
Since conditional DependsOn is not supported this undocumented way of implicitely making dependency through tags is used. | def _depend_on_lambda_permissions_using_tag(self, bucket, permission):
"""
Since conditional DependsOn is not supported this undocumented way of
implicitely making dependency through tags is used.
See https://stackoverflow.com/questions/34607476/cloudformation-apply-condition-on-depend... |
Returns the Lambda Permission resource allowing SNS to invoke the function this event source triggers. | def to_cloudformation(self, **kwargs):
"""Returns the Lambda Permission resource allowing SNS to invoke the function this event source triggers.
:param dict kwargs: no existing resources need to be modified
:returns: a list of vanilla CloudFormation Resources, to which this SNS event expands
... |
If this API Event Source refers to an explicit API resource resolve the reference and grab necessary data from the explicit API | def resources_to_link(self, resources):
"""
If this API Event Source refers to an explicit API resource, resolve the reference and grab
necessary data from the explicit API
"""
rest_api_id = self.RestApiId
if isinstance(rest_api_id, dict) and "Ref" in rest_api_id:
... |
If the Api event source has a RestApi property then simply return the Lambda Permission resource allowing API Gateway to call the function. If no RestApi is provided then additionally inject the path method and the x - amazon - apigateway - integration into the Swagger body for a provided implicit API. | def to_cloudformation(self, **kwargs):
"""If the Api event source has a RestApi property, then simply return the Lambda Permission resource allowing
API Gateway to call the function. If no RestApi is provided, then additionally inject the path, method, and the
x-amazon-apigateway-integration int... |
Adds the path and method for this Api event source to the Swagger body for the provided RestApi. | def _add_swagger_integration(self, api, function):
"""Adds the path and method for this Api event source to the Swagger body for the provided RestApi.
:param model.apigateway.ApiGatewayRestApi rest_api: the RestApi to which the path and method should be added.
"""
swagger_body = api.get... |
Resolves references to parameters within the given dictionary recursively. Other intrinsic functions such as !GetAtt !Sub or !Ref to non - parameters will be left untouched. | def resolve_parameter_refs(self, input):
"""
Resolves references to parameters within the given dictionary recursively. Other intrinsic functions such as
!GetAtt, !Sub or !Ref to non-parameters will be left untouched.
Result is a dictionary where parameter values are inlined. Don't pass... |
Customers can provide a reference to a derived SAM resource such as Alias of a Function or Stage of an API resource. This method recursively walks the tree converting all derived references to the real resource name if it is present. | def resolve_sam_resource_refs(self, input, supported_resource_refs):
"""
Customers can provide a reference to a "derived" SAM resource such as Alias of a Function or Stage of an API
resource. This method recursively walks the tree, converting all derived references to the real resource name,
... |
Some SAM resources have their logical ids mutated from the original id that the customer writes in the template. This method recursively walks the tree and updates these logical ids from the old value to the new value that is generated by SAM. | def resolve_sam_resource_id_refs(self, input, supported_resource_id_refs):
"""
Some SAM resources have their logical ids mutated from the original id that the customer writes in the
template. This method recursively walks the tree and updates these logical ids from the old value
to the n... |
Driver method that performs the actual traversal of input and calls the appropriate resolver_method when to perform the resolution. | def _traverse(self, input, resolution_data, resolver_method):
"""
Driver method that performs the actual traversal of input and calls the appropriate `resolver_method` when
to perform the resolution.
:param input: Any primitive type (dict, array, string etc) whose value might contain a... |
Traverse a dictionary to resolve intrinsic functions on every value | def _traverse_dict(self, input_dict, resolution_data, resolver_method):
"""
Traverse a dictionary to resolve intrinsic functions on every value
:param input_dict: Input dictionary to traverse
:param resolution_data: Data that the `resolver_method` needs to operate
:param resolve... |
Traverse a list to resolve intrinsic functions on every element | def _traverse_list(self, input_list, resolution_data, resolver_method):
"""
Traverse a list to resolve intrinsic functions on every element
:param input_list: List of input
:param resolution_data: Data that the `resolver_method` needs to operate
:param resolver_method: Method th... |
Try to resolve parameter references on the given input object. The object could be of any type. If the input is not in the format used by intrinsics ( ie. dictionary with one key ) input is returned unmodified. If the single key in dictionary is one of the supported intrinsic function types go ahead and try to resolve ... | def _try_resolve_parameter_refs(self, input, parameters):
"""
Try to resolve parameter references on the given input object. The object could be of any type.
If the input is not in the format used by intrinsics (ie. dictionary with one key), input is returned
unmodified. If the single ke... |
Try to resolve SAM resource references on the given template. If the given object looks like one of the supported intrinsics it calls the appropriate resolution on it. If not this method returns the original input unmodified. | def _try_resolve_sam_resource_refs(self, input, supported_resource_refs):
"""
Try to resolve SAM resource references on the given template. If the given object looks like one of the
supported intrinsics, it calls the appropriate resolution on it. If not, this method returns the original input
... |
Try to resolve SAM resource id references on the given template. If the given object looks like one of the supported intrinsics it calls the appropriate resolution on it. If not this method returns the original input unmodified. | def _try_resolve_sam_resource_id_refs(self, input, supported_resource_id_refs):
"""
Try to resolve SAM resource id references on the given template. If the given object looks like one of the
supported intrinsics, it calls the appropriate resolution on it. If not, this method returns the original... |
Can the input represent an intrinsic function in it? | def _is_intrinsic_dict(self, input):
"""
Can the input represent an intrinsic function in it?
:param input: Object to be checked
:return: True, if the input contains a supported intrinsic function. False otherwise
"""
# All intrinsic functions are dictionaries with just... |
Returns the CloudWatch Logs Subscription Filter and Lambda Permission to which this CloudWatch Logs event source corresponds. | def to_cloudformation(self, **kwargs):
"""Returns the CloudWatch Logs Subscription Filter and Lambda Permission to which this CloudWatch Logs event source
corresponds.
:param dict kwargs: no existing resources need to be modified
:returns: a list of vanilla CloudFormation Resources, to ... |
Converts the given template to IAM - ready policy statement by substituting template parameters with the given values. | def convert(self, template_name, parameter_values):
"""
Converts the given template to IAM-ready policy statement by substituting template parameters with the given
values.
:param template_name: Name of the template
:param parameter_values: Values for all parameters of the templ... |
Is this a valid policy template dictionary | def _is_valid_templates_dict(policy_templates_dict, schema=None):
"""
Is this a valid policy template dictionary
:param dict policy_templates_dict: Data to be validated
:param dict schema: Optional, dictionary containing JSON Schema representing policy template
:return: True, if... |
Render a chart or page to local html files. | def render_chart_to_file(self, template_name: str, chart: Any, path: str):
"""
Render a chart or page to local html files.
:param chart: A Chart or Page object
:param path: The destination file which the html code write to
:param template_name: The name of template file.
... |
Decode base64 padding being optional. | def decode_base64(data: str) -> bytes:
"""Decode base64, padding being optional.
:param data: Base64 data as an ASCII byte string
:returns: The decoded byte string.
"""
missing_padding = len(data) % 4
if missing_padding != 0:
data += "=" * (4 - missing_padding)
return base64.decodeb... |
间隔折叠节点，当节点过多时可以解决节点显示过杂间隔。: param data: 节点数据: param interval: 指定间隔 | def _set_collapse_interval(data, interval):
"""
间隔折叠节点，当节点过多时可以解决节点显示过杂间隔。
:param data: 节点数据
:param interval: 指定间隔
"""
if interval <= 0:
return data
if data and isinstance(data, list):
for d in data:
children = d... |
Parses a string and returns a pin - num. | def parse_pin(name_str):
"""Parses a string and returns a pin-num."""
if len(name_str) < 1:
raise ValueError("Expecting pin name to be at least 4 charcters.")
if name_str[0] != 'P':
raise ValueError("Expecting pin name to start with P")
pin_str = name_str[1:].split('/')[0]
if not pin... |
Returns the numbered function ( i. e. USART6 ) for this AF. | def ptr(self):
"""Returns the numbered function (i.e. USART6) for this AF."""
if self.fn_num is None:
return self.func
return '{:s}{:d}'.format(self.func, self.fn_num) |
Prints the C representation of this AF. | def print(self):
"""Prints the C representation of this AF."""
if self.supported:
print(' AF', end='')
else:
print(' //', end='')
fn_num = self.fn_num
if fn_num is None:
fn_num = 0
print('({:2d}, {:8s}, {:2d}, {:10s}, {:8s}), // {:s}... |
Start the loop. | def run_loop(leds=all_leds):
"""
Start the loop.
:param `leds`: Which LEDs to light up upon switch press.
:type `leds`: sequence of LED objects
"""
print('Loop started.\nPress Ctrl+C to break out of the loop.')
while 1:
try:
if switch():
[led.on() for led... |
Search vpaths for the c file that matches the provided object_file. | def find_c_file(obj_file, vpath):
""" Search vpaths for the c file that matches the provided object_file.
:param str obj_file: object file to find the matching c file for
:param List[str] vpath: List of base paths, similar to gcc vpath
:return: str path to c file or None
"""
c_file = None
r... |
Find any MP_REGISTER_MODULE definitions in the provided c file. | def find_module_registrations(c_file):
""" Find any MP_REGISTER_MODULE definitions in the provided c file.
:param str c_file: path to c file to check
:return: List[(module_name, obj_module, enabled_define)]
"""
global pattern
if c_file is None:
# No c file to match the object file, ski... |
Generate header with module table entries for builtin modules. | def generate_module_table_header(modules):
""" Generate header with module table entries for builtin modules.
:param List[(module_name, obj_module, enabled_define)] modules: module defs
:return: None
"""
# Print header file for all external modules.
mod_defs = []
print("// Automatically ge... |
Reads test files | def readfiles():
""" Reads test files """
tests = list(filter(lambda x: x.endswith('.py'), os.listdir(TESTPATH)))
tests.sort()
files = []
for test in tests:
text = open(TESTPATH + test, 'r').read()
try:
class_, desc, cause, workaround, code = [x.rstrip() for x in \
... |
converts CPython module names into MicroPython equivalents | def uimports(code):
""" converts CPython module names into MicroPython equivalents """
for uimport in UIMPORTLIST:
uimport = bytes(uimport, 'utf8')
code = code.replace(uimport, b'u' + uimport)
return code |
indents paragraphs of text for rst formatting | def indent(block, spaces):
""" indents paragraphs of text for rst formatting """
new_block = ''
for line in block.split('\n'):
new_block += spaces + line + '\n'
return new_block |
creates a table given any set of columns | def gen_table(contents):
""" creates a table given any set of columns """
xlengths = []
ylengths = []
for column in contents:
col_len = 0
for entry in column:
lines = entry.split('\n')
for line in lines:
col_len = max(len(line) + 2, col_len)
... |
creates restructured text documents to display tests | def gen_rst(results):
""" creates restructured text documents to display tests """
# make sure the destination directory exists
try:
os.mkdir(DOCPATH)
except OSError as e:
if e.args[0] != errno.EEXIST and e.args[0] != errno.EISDIR:
raise
toctree = []
class_ = []
... |
Main function | def main():
""" Main function """
# set search path so that test scripts find the test modules (and no other ones)
os.environ['PYTHONPATH'] = TESTPATH
os.environ['MICROPYPATH'] = TESTPATH
files = readfiles()
results = run_tests(files)
gen_rst(results) |
Initializes the found DFU device so that we can program it. | def init():
"""Initializes the found DFU device so that we can program it."""
global __dev, __cfg_descr
devices = get_dfu_devices(idVendor=__VID, idProduct=__PID)
if not devices:
raise ValueError('No DFU device found')
if len(devices) > 1:
raise ValueError("Multiple DFU devices found... |
Performs a MASS erase ( i. e. erases the entire device. | def mass_erase():
"""Performs a MASS erase (i.e. erases the entire device."""
# Send DNLOAD with first byte=0x41
__dev.ctrl_transfer(0x21, __DFU_DNLOAD, 0, __DFU_INTERFACE,
"\x41", __TIMEOUT)
# Execute last command
if get_status() != __DFU_STATE_DFU_DOWNLOAD_BUSY:
ra... |
Erases a single page. | def page_erase(addr):
"""Erases a single page."""
if __verbose:
print("Erasing page: 0x%x..." % (addr))
# Send DNLOAD with first byte=0x41 and page address
buf = struct.pack("<BI", 0x41, addr)
__dev.ctrl_transfer(0x21, __DFU_DNLOAD, 0, __DFU_INTERFACE, buf, __TIMEOUT)
# Execute last co... |
Sets the address for the next operation. | def set_address(addr):
"""Sets the address for the next operation."""
# Send DNLOAD with first byte=0x21 and page address
buf = struct.pack("<BI", 0x21, addr)
__dev.ctrl_transfer(0x21, __DFU_DNLOAD, 0, __DFU_INTERFACE, buf, __TIMEOUT)
# Execute last command
if get_status() != __DFU_STATE_DFU_DO... |
Writes a buffer into memory. This routine assumes that memory has already been erased. | def write_memory(addr, buf, progress=None, progress_addr=0, progress_size=0):
"""Writes a buffer into memory. This routine assumes that memory has
already been erased.
"""
xfer_count = 0
xfer_bytes = 0
xfer_total = len(buf)
xfer_base = addr
while xfer_bytes < xfer_total:
if __v... |
Writes a single page. This routine assumes that memory has already been erased. | def write_page(buf, xfer_offset):
"""Writes a single page. This routine assumes that memory has already
been erased.
"""
xfer_base = 0x08000000
# Set mem write address
set_address(xfer_base+xfer_offset)
# Send DNLOAD with fw data
__dev.ctrl_transfer(0x21, __DFU_DNLOAD, 2, __DFU_INTERF... |
Exit DFU mode and start running the program. | def exit_dfu():
"""Exit DFU mode, and start running the program."""
# set jump address
set_address(0x08000000)
# Send DNLOAD with 0 length to exit DFU
__dev.ctrl_transfer(0x21, __DFU_DNLOAD, 0, __DFU_INTERFACE,
None, __TIMEOUT)
try:
# Execute last command
... |
Parses the struct defined by fmt from data stores the parsed fields into a named tuple using names. Returns the named tuple and the data with the struct stripped off. | def consume(fmt, data, names):
"""Parses the struct defined by `fmt` from `data`, stores the parsed fields
into a named tuple using `names`. Returns the named tuple, and the data
with the struct stripped off."""
size = struct.calcsize(fmt)
return named(struct.unpack(fmt, data[:size]), names), data[s... |
Reads a DFU file and parses the individual elements from the file. Returns an array of elements. Each element is a dictionary with the following keys: num - The element index address - The address that the element data should be written to. size - The size of the element ddata. data - The element data. If an error occu... | def read_dfu_file(filename):
"""Reads a DFU file, and parses the individual elements from the file.
Returns an array of elements. Each element is a dictionary with the
following keys:
num - The element index
address - The address that the element data should be written to.
size ... |
Returns a list of USB device which are currently in DFU mode. Additional filters ( like idProduct and idVendor ) can be passed in to refine the search. | def get_dfu_devices(*args, **kwargs):
"""Returns a list of USB device which are currently in DFU mode.
Additional filters (like idProduct and idVendor) can be passed in to
refine the search.
"""
# convert to list for compatibility with newer pyusb
return list(usb.core.find(*args, find_all=True,
... |
Returns an array which identifies the memory layout. Each entry of the array will contain a dictionary with the following keys: addr - Address of this memory segment last_addr - Last address contained within the memory segment. size - size of the segment in bytes num_pages - number of pages in the segment page_size - s... | def get_memory_layout(device):
"""Returns an array which identifies the memory layout. Each entry
of the array will contain a dictionary with the following keys:
addr - Address of this memory segment
last_addr - Last address contained within the memory segment.
size - siz... |
Prints a lits of devices detected in DFU mode. | def list_dfu_devices(*args, **kwargs):
"""Prints a lits of devices detected in DFU mode."""
devices = get_dfu_devices(*args, **kwargs)
if not devices:
print("No DFU capable devices found")
return
for device in devices:
print("Bus {} Device {:03d}: ID {:04x}:{:04x}"
... |
Writes the indicated elements into the target memory erasing as needed. | def write_elements(elements, mass_erase_used, progress=None):
"""Writes the indicated elements into the target memory,
erasing as needed.
"""
mem_layout = get_memory_layout(__dev)
for elem in elements:
addr = elem['addr']
size = elem['size']
data = elem['data']
elem_... |
Prints a progress report suitable for use on the command line. | def cli_progress(addr, offset, size):
"""Prints a progress report suitable for use on the command line."""
width = 25
done = offset * width // size
print("\r0x{:08x} {:7d} [{}{}] {:3d}% "
.format(addr, size, '=' * done, ' ' * (width - done),
offset * 100 // size), end="")
... |
Test program for verifying this files functionality. | def main():
"""Test program for verifying this files functionality."""
global __verbose
# Parse CMD args
parser = argparse.ArgumentParser(description='DFU Python Util')
#parser.add_argument("path", help="file path")
parser.add_argument(
"-l", "--list",
help="list available DFU de... |
Parses a string and returns a ( port - num pin - num ) tuple. | def parse_port_pin(name_str):
"""Parses a string and returns a (port-num, pin-num) tuple."""
if len(name_str) < 3:
raise ValueError("Expecting pin name to be at least 3 charcters.")
if name_str[0] != 'P':
raise ValueError("Expecting pin name to start with P")
if name_str[1] < 'A' or name... |
Prints the C representation of this AF. | def print(self):
"""Prints the C representation of this AF."""
cond_var = None
if self.supported:
cond_var = conditional_var('{}{}'.format(self.func, self.fn_num))
print_conditional_if(cond_var)
print(' AF', end='')
else:
print(' //', en... |
Parses a string and returns a ( port gpio_bit ) tuple. | def parse_port_pin(name_str):
"""Parses a string and returns a (port, gpio_bit) tuple."""
if len(name_str) < 3:
raise ValueError("Expecting pin name to be at least 3 characters")
if name_str[:2] != 'GP':
raise ValueError("Expecting pin name to start with GP")
if not name_str[2:].isdigit(... |
Simple run one operator and return the results. Args: outputs_info: a list of tuples which contains the element type and shape of each output. First element of the tuple is the dtype and the second element is the shape. More use case can be found in https:// github. com/ onnx/ onnx/ blob/ master/ onnx/ backend/ test/ r... | def run_node(cls,
node, # type: NodeProto
inputs, # type: Any
device='CPU', # type: Text
outputs_info=None, # type: Optional[Sequence[Tuple[numpy.dtype, Tuple[int, ...]]]]
**kwargs # type: Dict[Text, Any]
): # ty... |
Load data from an external file for tensor. | def load_external_data_for_tensor(tensor, base_dir): # type: (TensorProto, Text) -> None
"""
Load data from an external file for tensor.
@params
tensor: a TensorProto object.
base_dir: directory that contains the external data.
"""
if tensor.HasField("raw_data"): # already loaded
... |
Loads external tensors into model | def load_external_data_for_model(model, base_dir): # type: (ModelProto, Text) -> None
"""
Loads external tensors into model
@params
model: ModelProto to load external data to
base_dir: directory that contains external data
"""
for tensor in _get_all_tensors(model):
if uses_external... |
call to set all tensors as external data. save_model saves all the tensors data as external data after calling this function. | def convert_model_to_external_data(model, all_tensors_to_one_file=True, location=None):
# type: (ModelProto, bool, Optional[Text]) -> None
"""
call to set all tensors as external data. save_model saves all the tensors data as external data after calling this function.
@params
model: ModelProto to be... |
call to set all tensors data as embedded data. save_model saves all the tensors data as embedded data after calling this function. | def convert_model_from_external_data(model): # type: (ModelProto) -> None
"""
call to set all tensors data as embedded data. save_model saves all the tensors data as embedded data after calling this function.
@params
model: ModelProto to be converted.
"""
for tensor in _get_all_tensors(model):
... |
Write tensor data to an external file according to information in the external_data field. | def save_external_data(tensor, base_path): # type: (TensorProto, Text) -> None
"""
Write tensor data to an external file according to information in the `external_data` field.
@params
tensor: Tensor object to be serialized
base_path: System path of a folder where tensor data is to be stored
""... |
Create an iterator of tensors from node attributes of an ONNX model. | def _get_attribute_tensors(onnx_model_proto): # type: (ModelProto) -> Iterable[TensorProto]
"""Create an iterator of tensors from node attributes of an ONNX model."""
for node in onnx_model_proto.graph.node:
for attribute in node.attribute:
if attribute.HasField("t"):
yield ... |
Remove a field from a Tensor s external_data key - value store. | def remove_external_data_field(tensor, field_key): # type: (TensorProto, Text) -> None
"""
Remove a field from a Tensor's external_data key-value store.
Modifies tensor object in place.
@params
tensor: Tensor object from which value will be removed
field_key: The key of the field to be remove... |
Write external data of all tensors to files on disk. | def write_external_data_tensors(model, filepath): # type: (ModelProto, Text) -> ModelProto
"""
Write external data of all tensors to files on disk.
Note: This function also strips basepath information from all tensors' external_data fields.
@params
model: Model object which is the source of tenso... |
Imports a stdlib path and returns a handle to it eg. self. _import ( typing Optional ) - > Optional | def _import(self, path, name):
# type: (Text, Text) -> Text
"""Imports a stdlib path and returns a handle to it
eg. self._import("typing", "Optional") -> "Optional"
"""
imp = path.replace('/', '.')
self.imports[imp].add(name)
return name |
Import a referenced message and return a handle | def _import_message(self, type_name):
# type: (d.FieldDescriptorProto) -> Text
"""Import a referenced message and return a handle"""
name = cast(Text, type_name)
if name[0] == '.' and name[1].isupper() and name[2].islower():
# Message defined in this file
return ... |
Run command. | def run(self):
"""Run command."""
onnx_script = os.path.realpath(os.path.join(os.path.dirname(os.path.abspath(__file__)), "tools/mypy-onnx.py"))
returncode = subprocess.call([sys.executable, onnx_script])
sys.exit(returncode) |
Construct a NodeProto. | def make_node(
op_type, # type: Text
inputs, # type: Sequence[Text]
outputs, # type: Sequence[Text]
name=None, # type: Optional[Text]
doc_string=None, # type: Optional[Text]
domain=None, # type: Optional[Text]
**kwargs # type: Any
): # type: (...) -> NodeP... |
Construct an OperatorSetIdProto. | def make_operatorsetid(
domain, # type: Text
version, # type: int
): # type: (...) -> OperatorSetIdProto
"""Construct an OperatorSetIdProto.
Arguments:
domain (string): The domain of the operator set id
version (integer): Version of operator set id
"""
operatorsetid =... |
An internal graph to convert the input to a bytes or to False. | def _to_bytes_or_false(val): # type: (Union[Text, bytes]) -> Union[bytes, bool]
"""An internal graph to convert the input to a bytes or to False.
The criteria for conversion is as follows and should be python 2 and 3
compatible:
- If val is py2 str or py3 bytes: return bytes
- If val is py2 unicod... |
Makes an AttributeProto based on the value type. | def make_attribute(
key, # type: Text
value, # type: Any
doc_string=None # type: Optional[Text]
): # type: (...) -> AttributeProto
"""Makes an AttributeProto based on the value type."""
attr = AttributeProto()
attr.name = key
if doc_string:
attr.doc_string = doc_strin... |
Makes a ValueInfoProto based on the data type and shape. | def make_tensor_value_info(
name, # type: Text
elem_type, # type: int
shape, # type: Optional[Sequence[Union[Text, int]]]
doc_string="", # type: Text
shape_denotation=None, # type: Optional[List[Text]]
): # type: (...) -> ValueInfoProto
"""Makes a ValueInfoProto based o... |
Empties doc_string field on any nested protobuf messages | def strip_doc_string(proto): # type: (google.protobuf.message.Message) -> None
"""
Empties `doc_string` field on any nested protobuf messages
"""
assert isinstance(proto, google.protobuf.message.Message)
for descriptor in proto.DESCRIPTOR.fields:
if descriptor.name == 'doc_string':
... |
Converts a tensor def object to a numpy array. | def to_array(tensor): # type: (TensorProto) -> np.ndarray[Any]
"""Converts a tensor def object to a numpy array.
Inputs:
tensor: a TensorProto object.
Returns:
arr: the converted array.
"""
if tensor.HasField("segment"):
raise ValueError(
"Currently not supporti... |
Converts a numpy array to a tensor def. | def from_array(arr, name=None): # type: (np.ndarray[Any], Optional[Text]) -> TensorProto
"""Converts a numpy array to a tensor def.
Inputs:
arr: a numpy array.
name: (optional) the name of the tensor.
Returns:
tensor_def: the converted tensor def.
"""
tensor = TensorProto()... |
Serialize a in - memory proto to bytes | def _serialize(proto): # type: (Union[bytes, google.protobuf.message.Message]) -> bytes
'''
Serialize a in-memory proto to bytes
@params
proto is a in-memory proto, such as a ModelProto, TensorProto, etc
@return
Serialized proto in bytes
'''
if isinstance(proto, bytes):
return... |
Parse bytes into a in - memory proto | def _deserialize(s, proto): # type: (bytes, _Proto) -> _Proto
'''
Parse bytes into a in-memory proto
@params
s is bytes containing serialized proto
proto is a in-memory proto object
@return
The proto instance filled in by s
'''
if not isinstance(s, bytes):
raise ValueError... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.